@sanity/sdk 2.10.0 → 2.11.0

package/src/projects/projects.ts

@@ -1,35 +1,95 @@
 import {switchMap} from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
+import {type Project} from '../project/project'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {createFetcherStore} from '../utils/createFetcherStore'
 
 const API_VERSION = 'v2025-02-19'
 
+/** @public */
+export interface ProjectsOptions<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+> {
+  organizationId?: string
+  includeMembers?: IncludeMembers
+  includeFeatures?: IncludeFeatures
+  onlyExplicitMembership?: boolean
+}
+
+function normalizeProjectsOptions(options?: ProjectsOptions<boolean, boolean>) {
+  return {
+    organizationId: options?.organizationId,
+    includeMembers: options?.includeMembers ?? false,
+    includeFeatures: options?.includeFeatures ?? true,
+    onlyExplicitMembership: options?.onlyExplicitMembership ?? false,
+  }
+}
+
+/** @internal */
+export function getProjectsCacheKey(
+  _instance: SanityInstance,
+  options?: ProjectsOptions<boolean, boolean>,
+): string {
+  const {organizationId, includeMembers, includeFeatures, onlyExplicitMembership} =
+    normalizeProjectsOptions(options)
+  const orgKey = organizationId ? `:org:${organizationId}` : ''
+  const membersKey = includeMembers ? ':members' : ''
+  const featuresKey = includeFeatures ? ':features' : ''
+  const explicitKey = onlyExplicitMembership ? ':explicit' : ''
+  return `projects${orgKey}${membersKey}${featuresKey}${explicitKey}`
+}
+
 const projects = createFetcherStore({
   name: 'Projects',
-  getKey: (_instance, options?: {organizationId?: string; includeMembers?: boolean}) => {
-    const orgKey = options?.organizationId ? `:org:${options.organizationId}` : ''
-    const membersKey = options?.includeMembers === false ? ':no-members' : ''
-    return `projects${orgKey}${membersKey}`
-  },
-  fetcher: (instance) => (options?: {organizationId?: string; includeMembers?: boolean}) =>
+  getKey: getProjectsCacheKey,
+  fetcher: (instance) => (options?: ProjectsOptions<boolean, boolean>) =>
     getClientState(instance, {
       apiVersion: API_VERSION,
       scope: 'global',
-      requestTagPrefix: 'sanity.sdk.projects',
     }).observable.pipe(
       switchMap((client) => {
-        const organizationId = options?.organizationId
-        return client.observable.projects.list({
-          // client method has a type that expects false | undefined
-          includeMembers: !options?.includeMembers ? false : undefined,
-          organizationId,
+        const normalized = normalizeProjectsOptions(options)
+        const query = Object.fromEntries(
+          Object.entries(normalized)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, String(value)]),
+        )
+
+        return client.observable.request({
+          uri: '/projects',
+          query,
+          tag: 'projects.get',
         })
       }),
     ),
 })
 
+/**
+ * Public signature for the projects state source. The conditional generics
+ * cannot flow through `BoundStoreAction`, so we declare the signature here
+ * and assign the (already-correct) runtime function to it.
+ */
+type GetProjectsState = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  instance: SanityInstance,
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => StateSource<Project<IncludeMembers, IncludeFeatures>[] | undefined>
+
+type ResolveProjects = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  instance: SanityInstance,
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => Promise<Project<IncludeMembers, IncludeFeatures>[]>
+
 /** @public */
-export const getProjectsState = projects.getState
+export const getProjectsState: GetProjectsState = projects.getState
+
 /** @public */
-export const resolveProjects = projects.resolveState
+export const resolveProjects: ResolveProjects = projects.resolveState

package/src/query/queryStore.ts

@@ -24,7 +24,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DatasetHandle, isDatasetResource} from '../config/sanityConfig'
+import {type DatasetHandle} from '../config/sanityConfig'
 /*
  * Although this is an import dependency cycle, it is not a logical cycle:
  * 1. queryStore uses getPerspectiveState when resolving release perspectives
@@ -230,8 +230,7 @@ const listenToLiveClientAndSetLastLiveEventIds = ({
 }: StoreContext<QueryStoreState, BoundResourceKey>) => {
   const liveMessages$ = getClientState(instance, {
     apiVersion: QUERY_STORE_API_VERSION,
-    // temporary guard here until we're ready for everything to be queried via global api
-    ...(resource && !isDatasetResource(resource) ? {resource} : {}),
+    resource,
   }).observable.pipe(
     switchMap((client) =>
       defer(() =>

package/src/releases/releasesStore.test.ts

@@ -39,8 +39,8 @@ describe('releasesStore', () => {
       expect.objectContaining({
         query: 'releases::all()',
         perspective: 'raw',
-        resource: undefined,
         tag: 'releases',
+        resource: {dataset: 'test', projectId: 'test'},
       }),
     )
   })

package/src/releases/releasesStore.ts

@@ -1,7 +1,7 @@
 import {type SanityDocument} from '@sanity/types'
 import {map} from 'rxjs'
 
-import {type DocumentResource, isDatasetResource} from '../config/sanityConfig'
+import {type DocumentResource} from '../config/sanityConfig'
 /*
  * Although this is an import dependency cycle, it is not a logical cycle:
  * 1. releasesStore uses queryStore as a data source
@@ -84,7 +84,7 @@ const subscribeToReleases = ({
   const {observable: releases$} = getQueryState<ReleaseDocument[]>(instance, {
     query: RELEASES_QUERY,
     perspective: 'raw',
-    resource: resource && !isDatasetResource(resource) ? resource : undefined,
+    resource,
     tag: 'releases',
   })
   return releases$

package/src/store/createSanityInstance.ts

@@ -5,7 +5,6 @@ import {pickProperties} from '../utils/object'
 
 /**
  * Represents a Sanity.io resource instance with its own configuration and lifecycle
- * @remarks Instances form a hierarchy through parent/child relationships
  *
  * @public
  */
@@ -18,7 +17,6 @@ export interface SanityInstance {
 
   /**
    * Resolved configuration for this instance
-   * @remarks Merges values from parent instances where appropriate
    */
   readonly config: SanityConfig
 
@@ -44,13 +42,14 @@ export interface SanityInstance {
   /**
    * Gets the parent instance in the hierarchy
    * @returns Parent instance or undefined if this is the root
+   * @deprecated The parent/child instance hierarchy is deprecated. Use a single SanityInstance instead.
    */
   getParent(): SanityInstance | undefined
 
   /**
    * Creates a child instance with merged configuration
    * @param config - Configuration to merge with parent values
-   * @remarks Child instances inherit parent configuration but can override values
+   * @deprecated The parent/child instance hierarchy is deprecated. Use a single SanityInstance instead.
    */
   createChild(config: SanityConfig): SanityInstance
 
@@ -59,6 +58,7 @@ export interface SanityInstance {
    * matches the given target config using a shallow comparison.
    * @param targetConfig - A partial configuration object containing key-value pairs to match.
    * @returns The first matching instance or undefined if no match is found.
+   * @deprecated The parent/child instance hierarchy is deprecated. Use a single SanityInstance instead.
    */
   match(targetConfig: Partial<SanityConfig>): SanityInstance | undefined
 }

package/src/telemetry/devMode.test.ts

@@ -30,6 +30,14 @@ describe('isDevMode', () => {
     expect(isDevMode()).toBe(true)
   })
 
+  it('returns true on localhost even when NODE_ENV is production', () => {
+    vi.stubEnv('NODE_ENV', 'production')
+    vi.stubGlobal('window', {
+      location: {href: 'http://localhost:3000/'},
+    })
+    expect(isDevMode()).toBe(true)
+  })
+
   it('returns false for a non-local URL', () => {
     vi.stubEnv('NODE_ENV', 'test')
     vi.stubGlobal('window', {

package/src/telemetry/devMode.ts

@@ -17,21 +17,22 @@ function isLocalUrl(win: Window): boolean {
 }
 
 /**
- * Determines whether the SDK should enable dev-mode telemetry.
+ * Determines whether the SDK should enable dev-mode telemetry for the
+ * SDK consumer (i.e. a developer building an app with `@sanity/sdk`).
  *
- * Combines a browser URL check (localhost/127.0.0.1) with a Node.js
- * environment variable check (`NODE_ENV === 'development'`). Returns
- * false in production environments so bundlers can tree-shake the
- * telemetry code path entirely.
+ * Browser: returns true only when the URL is `localhost` or `127.0.0.1`.
+ * The URL check is the primary signal because consumer bundlers may or
+ * may not forward `NODE_ENV` to the browser reliably.
+ *
+ * Node (scripts / non-browser): falls back to `NODE_ENV === 'development'`.
+ *
+ * Bracket-notation `process.env['NODE_ENV']` is used to avoid bundler
+ * dead-code replacement.
  *
  * @returns True if the SDK is running in a development environment
  * @internal
  */
 export function isDevMode(): boolean {
-  if (typeof process !== 'undefined' && process.env?.['NODE_ENV'] === 'production') {
-    return false
-  }
-
   if (typeof window !== 'undefined') {
     return isLocalUrl(window)
   }

package/src/telemetry/initTelemetry.test.ts

@@ -205,21 +205,4 @@ describe('initTelemetry', () => {
 
     instance.dispose()
   })
-
-  it('finds manager through parent-child instance chain', async () => {
-    vi.mocked(isDevMode).mockReturnValue(true)
-
-    const root = createSanityInstance()
-    const child = root.createChild({})
-
-    initTelemetry(root, 'abc123')
-    await flushPromises()
-
-    trackHookMounted(child, 'useUsers')
-
-    const manager = vi.mocked(createTelemetryManager).mock.results[0].value
-    expect(manager.logHookFirstUsed).toHaveBeenCalledWith('useUsers')
-
-    root.dispose()
-  })
 })

package/src/telemetry/initTelemetry.ts

@@ -187,19 +187,9 @@ export function trackHookMounted(instance: SanityInstance, hookName: string): vo
 }
 
 function findManager(instance: SanityInstance): TelemetryManager | undefined {
-  let current: SanityInstance | undefined = instance
-  while (current) {
-    const manager = telemetryManagers.get(current)
-    if (manager) return manager
-    current = typeof current.getParent === 'function' ? current.getParent() : undefined
-  }
-  return undefined
+  return telemetryManagers.get(instance)
 }
 
 function getRootInstance(instance: SanityInstance): SanityInstance {
-  let current = instance
-  while (typeof current.getParent === 'function' && current.getParent()) {
-    current = current.getParent()!
-  }
-  return current
+  return instance
 }