@sanity/sdk 2.5.0 → 2.7.0

package/src/releases/releasesStore.test.ts

@@ -1,45 +1,47 @@
-import {type SanityClient} from '@sanity/client'
-import {of, Subject} from 'rxjs'
+import {NEVER, Observable, type Observer, of, Subject} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {getClientState} from '../client/clientStore'
+import {getQueryState, resolveQuery} from '../query/queryStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {listenQuery} from '../utils/listenQuery'
 import {getActiveReleasesState, type ReleaseDocument} from './releasesStore'
 
 // Mock dependencies
-vi.mock('../client/clientStore', () => ({
-  getClientState: vi.fn(),
-}))
-vi.mock('../utils/listenQuery', () => ({
-  listenQuery: vi.fn(),
-}))
-
-// Mock console.error to prevent test runner noise and allow verification
-let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+vi.mock('../query/queryStore')
 
 describe('releasesStore', () => {
   let instance: SanityInstance
-  const mockClient = {} as SanityClient
 
   beforeEach(() => {
-    vi.resetAllMocks()
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    vi.clearAllMocks()
 
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of(mockClient),
-    } as StateSource<SanityClient>)
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: NEVER as Observable<ReleaseDocument[] | undefined>,
+    } as StateSource<ReleaseDocument[] | undefined>)
+
+    vi.mocked(resolveQuery).mockResolvedValue(undefined)
   })
 
   afterEach(() => {
     instance.dispose()
-    consoleErrorSpy.mockRestore()
   })
 
-  it('should set active releases state when listenQuery succeeds', async () => {
+  it('should set active releases state when the releases query emits', async () => {
+    const teardown = vi.fn()
+    const subscriber = vi
+      .fn<(observer: Observer<ReleaseDocument[] | undefined>) => () => void>()
+      .mockReturnValue(teardown)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ReleaseDocument[] | undefined>)
+
     // note that the order of the releases is important here -- they get sorted
     const mockReleases: ReleaseDocument[] = [
       {
@@ -56,21 +58,24 @@ describe('releasesStore', () => {
       } as ReleaseDocument,
     ]
 
-    vi.mocked(listenQuery).mockReturnValue(of(mockReleases))
-
     const state = getActiveReleasesState(instance)
 
+    const [observer] = subscriber.mock.lastCall!
+
+    observer.next(mockReleases)
+
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual(mockReleases.reverse())
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
-
-    vi.useRealTimers()
   })
 
-  it('should update active releases state when listenQuery emits new data', async () => {
+  it('should update active releases state when the query emits new data', async () => {
     const releasesSubject = new Subject<ReleaseDocument[]>()
-    vi.mocked(listenQuery).mockReturnValue(releasesSubject.asObservable())
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: releasesSubject.asObservable(),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
     const state = getActiveReleasesState(instance)
 
@@ -109,65 +114,58 @@ describe('releasesStore', () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual(updatedReleases.reverse())
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle empty array from listenQuery', async () => {
-    // Configure listenQuery to return an empty array
-    vi.mocked(listenQuery).mockReturnValue(of([]))
+  it('should handle empty array from the query', async () => {
+    // Configure query to return an empty array
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => [],
+      observable: of([]),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
     const state = getActiveReleasesState(instance)
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual([]) // Should be set to empty array
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle null/undefined from listenQuery by defaulting to empty array', async () => {
+  it('should handle null/undefined from the query by defaulting to empty array', async () => {
     // Test null case
-    vi.mocked(listenQuery).mockReturnValue(of(null))
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => null as unknown as ReleaseDocument[] | undefined,
+      observable: of(null as unknown as ReleaseDocument[] | undefined),
+    } as StateSource<ReleaseDocument[] | undefined>)
     const state = getActiveReleasesState(instance)
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
 
     // Test undefined case
-    vi.mocked(listenQuery).mockReturnValue(of(undefined))
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: of(undefined),
+    } as StateSource<ReleaseDocument[] | undefined>)
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle errors from listenQuery by retrying and eventually setting error state', async () => {
-    vi.useFakeTimers()
-    const error = new Error('Query failed')
+  it('should not crash when the releases query errors', async () => {
     const subject = new Subject<ReleaseDocument[]>()
-    vi.mocked(listenQuery).mockReturnValue(subject.asObservable())
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: subject.asObservable(),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
-    // initialize the store
     const state = getActiveReleasesState(instance)
 
-    // Error the subject
-    subject.error(error)
-
-    // Advance enough to cover the retry attempts (exponential backoff: 1s, 2s, 4s)
-    for (let i = 0; i < 3; i++) {
-      const delay = Math.pow(2, i) * 1000
-      await vi.advanceTimersByTimeAsync(delay)
-    }
+    subject.error(new Error('Query failed'))
 
-    // Verify error was logged at least once during retries
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '[releases] Error in subscription:',
-      error,
-      'Retry count:',
-      expect.any(Number),
-    )
+    await new Promise((resolve) => setTimeout(resolve, 0))
 
-    // not sure how to test state.setError()
     expect(state.getCurrent()).toEqual(undefined)
-
-    vi.useRealTimers()
   })
 })

package/src/releases/releasesStore.ts

@@ -1,15 +1,22 @@
-import {type SanityClient} from '@sanity/client'
 import {type SanityDocument} from '@sanity/types'
-import {catchError, EMPTY, retry, switchMap, timer} from 'rxjs'
+import {map} from 'rxjs'
 
-import {getClientState} from '../client/clientStore'
+/*
+ * Although this is an import dependency cycle, it is not a logical cycle:
+ * 1. releasesStore uses queryStore as a data source
+ * 2. queryStore calls getPerspectiveState for computing release perspectives
+ * 3. getPerspectiveState uses releasesStore as a data source
+ * 4. however, queryStore does not use getPerspectiveState for the perspective used in releasesStore ("raw")
+ */
+// eslint-disable-next-line import/no-cycle
+import {getQueryState} from '../query/queryStore'
 import {bindActionByDataset, type BoundDatasetKey} from '../store/createActionBinder'
 import {createStateSourceAction} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
-import {listenQuery} from '../utils/listenQuery'
 import {sortReleases} from './utils/sortReleases'
 
 const ARCHIVED_RELEASE_STATES = ['archived', 'published']
+const STABLE_EMPTY_RELEASES: ReleaseDocument[] = []
 
 /**
  * Represents a document in a Sanity dataset that represents release options.
@@ -55,51 +62,30 @@ export const getActiveReleasesState = bindActionByDataset(
 )
 
 const RELEASES_QUERY = 'releases::all()'
-const QUERY_PARAMS = {}
 
 const subscribeToReleases = ({
   instance,
   state,
   key: {projectId, dataset},
 }: StoreContext<ReleasesStoreState, BoundDatasetKey>) => {
-  return getClientState(instance, {
-    apiVersion: '2025-04-10',
+  const {observable: releases$} = getQueryState<ReleaseDocument[]>(instance, {
+    query: RELEASES_QUERY,
     perspective: 'raw',
     projectId,
     dataset,
+    tag: 'releases',
   })
-    .observable.pipe(
-      switchMap((client: SanityClient) =>
-        // releases are system documents, and are not supported by useQueryState
-        listenQuery<ReleaseDocument[]>(client, RELEASES_QUERY, QUERY_PARAMS, {
-          tag: 'releases-listener',
-          throttleTime: 1000,
-          transitions: ['update', 'appear', 'disappear'],
-        }).pipe(
-          retry({
-            count: 3,
-            delay: (error, retryCount) => {
-              // eslint-disable-next-line no-console
-              console.error('[releases] Error in subscription:', error, 'Retry count:', retryCount)
-              return timer(Math.min(1000 * Math.pow(2, retryCount), 10000))
-            },
-          }),
-          catchError((error) => {
-            state.set('setError', {error})
-            return EMPTY
-          }),
-        ),
-      ),
-    )
-    .subscribe({
-      next: (releases) => {
+  return releases$
+    .pipe(
+      map((releases) => {
         // logic here mirrors that of studio:
         // https://github.com/sanity-io/sanity/blob/156e8fa482703d99219f08da7bacb384517f1513/packages/sanity/src/core/releases/store/useActiveReleases.ts#L29
         state.set('setActiveReleases', {
-          activeReleases: sortReleases(releases ?? [])
+          activeReleases: sortReleases(releases ?? STABLE_EMPTY_RELEASES)
             .filter((release) => !ARCHIVED_RELEASE_STATES.includes(release.state))
             .reverse(),
         })
-      },
-    })
+      }),
+    )
+    .subscribe({error: (error) => state.set('setError', {error})})
 }

package/src/releases/utils/isReleasePerspective.ts

@@ -0,0 +1,7 @@
+import {type PerspectiveHandle, type ReleasePerspective} from '../../config/sanityConfig'
+
+export const isReleasePerspective = (
+  perspective: PerspectiveHandle['perspective'],
+): perspective is ReleasePerspective => {
+  return typeof perspective === 'object' && perspective !== null && 'releaseName' in perspective
+}

package/src/store/createActionBinder.test.ts

@@ -1,6 +1,13 @@
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {bindActionByDataset, bindActionGlobally, createActionBinder} from './createActionBinder'
+import {type DocumentSource} from '../config/sanityConfig'
+import {
+  bindActionByDataset,
+  bindActionBySource,
+  bindActionBySourceAndPerspective,
+  bindActionGlobally,
+  createActionBinder,
+} from './createActionBinder'
 import {createSanityInstance} from './createSanityInstance'
 import {createStoreInstance} from './createStoreInstance'
 
@@ -153,3 +160,206 @@ describe('bindActionGlobally', () => {
     expect(storeInstance.dispose).toHaveBeenCalledTimes(1)
   })
 })
+
+describe('bindActionBySource', () => {
+  it('should throw an error when provided an invalid source', () => {
+    const storeDefinition = {
+      name: 'SourceStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySource(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    expect(() =>
+      boundAction(instance, {source: {invalid: 'source'} as unknown as DocumentSource}),
+    ).toThrow('Received invalid source:')
+  })
+
+  it('should throw an error when no source provided and projectId/dataset are missing', () => {
+    const storeDefinition = {
+      name: 'SourceStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySource(storeDefinition, action)
+    const instance = createSanityInstance({projectId: '', dataset: ''})
+
+    expect(() => boundAction(instance, {})).toThrow(
+      'This API requires a project ID and dataset configured.',
+    )
+  })
+
+  it('should work correctly with a valid dataset source', () => {
+    const storeDefinition = {
+      name: 'SourceStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySource(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    const result = boundAction(instance, {
+      source: {projectId: 'proj2', dataset: 'ds2'},
+    })
+    expect(result).toBe('success')
+  })
+})
+
+describe('bindActionBySourceAndPerspective', () => {
+  it('should throw an error when provided an invalid source', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    expect(() =>
+      boundAction(instance, {
+        source: {invalid: 'source'} as unknown as DocumentSource,
+        perspective: 'drafts',
+      }),
+    ).toThrow('Received invalid source:')
+  })
+
+  it('should throw an error when no source provided and projectId/dataset are missing', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({projectId: '', dataset: ''})
+
+    expect(() => boundAction(instance, {perspective: 'drafts'})).toThrow(
+      'This API requires a project ID and dataset configured.',
+    )
+  })
+
+  it('should work correctly with a valid dataset source and explicit perspective', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    const result = boundAction(instance, {
+      source: {projectId: 'proj2', dataset: 'ds2'},
+      perspective: 'drafts',
+    })
+    expect(result).toBe('success')
+  })
+
+  it('should work correctly with valid dataset source and no perspective (falls back to drafts)', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    const result = boundAction(instance, {
+      source: {projectId: 'proj1', dataset: 'ds1'},
+    })
+    expect(result).toBe('success')
+  })
+
+  it('should use instance.config.perspective when options.perspective is not provided', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((context) => context.key)
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({
+      projectId: 'proj1',
+      dataset: 'ds1',
+      perspective: 'published',
+    })
+
+    const result = boundAction(instance, {})
+    expect(result).toEqual(
+      expect.objectContaining({
+        name: 'proj1.ds1:published',
+        perspective: 'published',
+      }),
+    )
+  })
+
+  it('should create separate store instances for different perspectives', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((context, _options, increment: number) => {
+      context.state.counter += increment
+      return context.state.counter
+    })
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    // Use unique project/dataset so we don't reuse stores from other tests
+    const instance = createSanityInstance({
+      projectId: 'perspective-isolation',
+      dataset: 'ds1',
+    })
+
+    const resultDrafts = boundAction(instance, {perspective: 'drafts'}, 3)
+    const resultPublished = boundAction(instance, {perspective: 'published'}, 4)
+
+    expect(resultDrafts).toBe(3)
+    expect(resultPublished).toBe(4)
+    // Two stores: one for drafts, one for published
+    expect(vi.mocked(createStoreInstance)).toHaveBeenCalledTimes(2)
+  })
+
+  it('should create separate store instance for release perspective', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((_context) => 'success')
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
+
+    const result = boundAction(instance, {
+      perspective: {releaseName: 'release1'},
+    })
+    expect(result).toBe('success')
+    expect(vi.mocked(createStoreInstance)).toHaveBeenCalledWith(
+      instance,
+      expect.objectContaining({
+        name: 'proj1.ds1:release1',
+        perspective: {releaseName: 'release1'},
+      }),
+      storeDefinition,
+    )
+  })
+
+  it('should reuse same store when same source and perspective are used', () => {
+    const storeDefinition = {
+      name: 'PerspectiveStore',
+      getInitialState: () => ({counter: 0}),
+    }
+    const action = vi.fn((context, _options, increment: number) => {
+      context.state.counter += increment
+      return context.state.counter
+    })
+    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    // Use unique project/dataset so we don't reuse stores from other tests
+    const instance = createSanityInstance({
+      projectId: 'perspective-reuse',
+      dataset: 'ds1',
+    })
+
+    const result1 = boundAction(instance, {perspective: 'drafts'}, 2)
+    const result2 = boundAction(instance, {perspective: 'drafts'}, 3)
+
+    expect(result1).toBe(2)
+    expect(result2).toBe(5)
+    expect(vi.mocked(createStoreInstance)).toHaveBeenCalledTimes(1)
+  })
+})

package/src/store/createActionBinder.ts

@@ -1,10 +1,27 @@
-import {type DocumentSource, SOURCE_ID} from '../config/sanityConfig'
+import {type ClientPerspective} from '@sanity/client'
+
+import {
+  type DatasetHandle,
+  type DocumentSource,
+  isCanvasSource,
+  isDatasetSource,
+  isMediaLibrarySource,
+  type ReleasePerspective,
+} from '../config/sanityConfig'
+import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type SanityInstance} from './createSanityInstance'
 import {createStoreInstance, type StoreInstance} from './createStoreInstance'
 import {type StoreState} from './createStoreState'
 import {type StoreContext, type StoreDefinition} from './defineStore'
 
-export type BoundDatasetKey = {
+export interface BoundSourceKey {
+  name: string
+  source: DocumentSource
+}
+export interface BoundPerspectiveKey extends BoundSourceKey {
+  perspective: ClientPerspective | ReleasePerspective
+}
+export interface BoundDatasetKey {
   name: string
   projectId: string
   dataset: string
@@ -149,26 +166,98 @@ export const bindActionByDataset = createActionBinder<
   return {name: `${projectId}.${dataset}`, projectId, dataset}
 })
 
+const createSourceKey = (instance: SanityInstance, source?: DocumentSource): BoundSourceKey => {
+  let name: string | undefined
+  let sourceForKey: DocumentSource | undefined
+  if (source) {
+    sourceForKey = source
+    if (isDatasetSource(source)) {
+      name = `${source.projectId}.${source.dataset}`
+    } else if (isMediaLibrarySource(source)) {
+      name = `media-library:${source.mediaLibraryId}`
+    } else if (isCanvasSource(source)) {
+      name = `canvas:${source.canvasId}`
+    } else {
+      throw new Error(`Received invalid source: ${JSON.stringify(source)}`)
+    }
+    return {name, source: sourceForKey}
+  }
+
+  // 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: `${projectId}.${dataset}`, source: {projectId, dataset}}
+}
+
 /**
  * Binds an action to a store that's scoped to a specific document source.
  **/
 export const bindActionBySource = createActionBinder<
-  {name: string},
+  BoundSourceKey,
   [{source?: DocumentSource}, ...unknown[]]
 >((instance, {source}) => {
-  if (source) {
-    const id = source[SOURCE_ID]
-    if (!id) throw new Error('Invalid source (missing ID information)')
-    if (Array.isArray(id)) return {name: id.join(':')}
-    return {name: `${id.projectId}.${id.dataset}`}
-  }
+  return createSourceKey(instance, source)
+})
 
-  const {projectId, dataset} = instance.config
+/**
+ * Binds an action to a store that's scoped to a specific document source and perspective.
+ *
+ * @remarks
+ * This creates actions that operate on state isolated to a specific document source and perspective.
+ * Different document sources and perspectives will have separate states.
+ *
+ * This is mostly useful for stores that do batch fetching operations, since the query store
+ * can isolate single queries by perspective.
+ *
+ * @throws Error if source or perspective is missing from the Sanity instance config
+ *
+ * @example
+ * ```ts
+ * // Define a store
+ * const documentStore = defineStore<DocumentState>({
+ *   name: 'Document',
+ *   getInitialState: () => ({ documents: {} }),
+ *   // ...
+ * })
+ *
+ * // Create source-and-perspective-specific actions
+ * export const fetchDocuments = bindActionBySourceAndPerspective(
+ *   documentStore,
+ *   ({instance, state}, documentId) => {
+ *     // This state is isolated to the specific document source and perspective
+ *     // ...fetch logic...
+ *   }
+ * )
+ *
+ * // Usage
+ * fetchDocument(sanityInstance, 'doc123')
+ * ```
+ */
+export const bindActionBySourceAndPerspective = createActionBinder<
+  BoundPerspectiveKey,
+  [DatasetHandle, ...unknown[]]
+>((instance, options): BoundPerspectiveKey => {
+  const {source, perspective} = options
+  // TODO: remove reference to instance.config.perspective when we get to v3
+  const utilizedPerspective = perspective ?? instance.config.perspective ?? 'drafts'
+  let perspectiveKey: string
+  if (isReleasePerspective(utilizedPerspective)) {
+    perspectiveKey = utilizedPerspective.releaseName
+  } else if (typeof utilizedPerspective === 'string') {
+    perspectiveKey = utilizedPerspective
+  } else {
+    // "StackablePerspective", shouldn't be a common case, but just in case
+    perspectiveKey = JSON.stringify(utilizedPerspective)
+  }
+  const sourceKey = createSourceKey(instance, source)
 
-  if (!projectId || !dataset) {
-    throw new Error('This API requires a project ID and dataset configured.')
+  return {
+    name: `${sourceKey.name}:${perspectiveKey}`,
+    source: sourceKey.source,
+    perspective: utilizedPerspective,
   }
-  return {name: `${projectId}.${dataset}`}
 })
 
 /**