@sanity/sdk 2.9.0 → 2.11.0

package/src/document/reducers.ts

@@ -1,11 +1,11 @@
 import {DocumentId, getDraftId, getPublishedId, getVersionId} from '@sanity/id-utils'
 import {type Mutation, type PatchOperations, type SanityDocumentLike} from '@sanity/types'
-import {omit} from 'lodash-es'
 
 import {type DocumentHandle} from '../config/sanityConfig'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
+import {omitProperty} from '../utils/object'
 import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {type DocumentAction} from './actions'
 import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
@@ -392,7 +392,7 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
             local: documentId in working ? working[documentId] : local,
             unverifiedRevisions:
               prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
-                ? omit(unverifiedRevisions, prev.outgoing.transactionId)
+                ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
                 : unverifiedRevisions,
           }
           return [documentId, next] as const
@@ -420,7 +420,7 @@ export function applyRemoteDocument(
   const revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : undefined
   let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS
   if (revision && revisionToVerify) {
-    unverifiedRevisions = omit(prevUnverifiedRevisions, revision)
+    unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)
   }
 
   // if this remote document is from a `'sync'` event (meaning that the whole
@@ -547,7 +547,7 @@ export function removeSubscriptionIdFromDocument(
 
   if (!prevDocState) return prev
   if (!subscriptions.length) {
-    return {...prev, documentStates: omit(prev.documentStates, documentId)}
+    return {...prev, documentStates: omitProperty(prev.documentStates, documentId)}
   }
   return {
     ...prev,

package/src/document/sharedListener.ts

@@ -14,7 +14,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
+import {type DocumentResource} from '../config/sanityConfig'
 import {type SanityInstance} from '../store/createSanityInstance'
 
 const API_VERSION = 'v2025-05-06'
@@ -26,13 +26,12 @@ export interface SharedListener {
 
 export function createSharedListener(
   instance: SanityInstance,
-  source?: DocumentSource,
+  resource?: DocumentResource,
 ): SharedListener {
   const dispose$ = new Subject<void>()
   const events$ = getClientState(instance, {
     apiVersion: API_VERSION,
-    // TODO: remove in v3 when we're ready for everything to be queried via source
-    source: source && !isDatasetSource(source) ? source : undefined,
+    resource,
   }).observable.pipe(
     switchMap((client) =>
       // TODO: it seems like the client.listen method is not emitting disconnected
@@ -68,12 +67,11 @@ export function createSharedListener(
   }
 }
 
-export function createFetchDocument(instance: SanityInstance, source?: DocumentSource) {
+export function createFetchDocument(instance: SanityInstance, resource?: DocumentResource) {
   return function (documentId: string): Observable<SanityDocument | null> {
     return getClientState(instance, {
       apiVersion: API_VERSION,
-      // TODO: remove in v3 when we're ready for everything to be queried via source
-      source: source && !isDatasetSource(source) ? source : undefined,
+      resource,
     }).observable.pipe(
       switchMap((client) => {
         // creates a observable request to the /doc/{documentId} endpoint for a given document id

package/src/organization/organization.test-d.ts

@@ -0,0 +1,102 @@
+import {expectTypeOf, test} from 'vitest'
+
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {
+  getOrganizationState,
+  type Organization,
+  type OrganizationBase,
+  type OrganizationMember,
+  resolveOrganization,
+} from './organization'
+
+const instance = {} as SanityInstance
+
+test('resolveOrganization — default call: members and features both omitted by default', () => {
+  expectTypeOf(resolveOrganization(instance, {organizationId: 'org_1'})).resolves.toEqualTypeOf<
+    Organization<false, false>
+  >()
+  type Result = Awaited<ReturnType<typeof resolveOrganization<false, false>>>
+  expectTypeOf<Result['id']>().toEqualTypeOf<string>()
+})
+
+test('resolveOrganization — includeMembers: true adds members to the type', () => {
+  expectTypeOf(
+    resolveOrganization(instance, {organizationId: 'org_1', includeMembers: true}),
+  ).resolves.toEqualTypeOf<Organization<true, false>>()
+  type Result = Awaited<ReturnType<typeof resolveOrganization<true, false>>>
+  expectTypeOf<Result['members']>().toEqualTypeOf<OrganizationMember[]>()
+})
+
+test('resolveOrganization — includeFeatures: true adds features to the type', () => {
+  expectTypeOf(
+    resolveOrganization(instance, {organizationId: 'org_1', includeFeatures: true}),
+  ).resolves.toEqualTypeOf<Organization<false, true>>()
+})
+
+test('resolveOrganization — both flags true → both arrays present', () => {
+  expectTypeOf(
+    resolveOrganization(instance, {
+      organizationId: 'org_1',
+      includeMembers: true,
+      includeFeatures: true,
+    }),
+  ).resolves.toEqualTypeOf<Organization<true, true>>()
+})
+
+test('resolveOrganization — rejects non-boolean flag values', () => {
+  // @ts-expect-error — includeMembers must be a boolean
+  void resolveOrganization(instance, {organizationId: 'org_1', includeMembers: 'yes'})
+})
+
+test('resolveOrganization — requires organizationId', () => {
+  // @ts-expect-error — organizationId is required
+  void resolveOrganization(instance, {})
+})
+
+test('resolveOrganization — non-literal boolean flag makes members optional', () => {
+  const includeMembers = false as boolean
+  expectTypeOf(
+    resolveOrganization(instance, {organizationId: 'org_1', includeMembers}),
+  ).resolves.toEqualTypeOf<Organization<boolean, false>>()
+})
+
+test('getOrganizationState — default call returns bare-base StateSource', () => {
+  expectTypeOf(getOrganizationState(instance, {organizationId: 'org_1'})).toEqualTypeOf<
+    StateSource<Organization<false, false> | undefined>
+  >()
+})
+
+test('getOrganizationState — both flags true narrows the StateSource value type', () => {
+  expectTypeOf(
+    getOrganizationState(instance, {
+      organizationId: 'org_1',
+      includeMembers: true,
+      includeFeatures: true,
+    }),
+  ).toEqualTypeOf<StateSource<Organization<true, true> | undefined>>()
+})
+
+test('Organization — wide boolean for IncludeMembers makes members optional', () => {
+  expectTypeOf<Organization<boolean, true>>().toEqualTypeOf<
+    OrganizationBase & {members?: OrganizationMember[]} & {features: string[]}
+  >()
+  expectTypeOf<Pick<Organization<boolean, true>, 'members'>>().toEqualTypeOf<{
+    members?: OrganizationMember[]
+  }>()
+})
+
+test('Organization — wide boolean for IncludeFeatures makes features optional', () => {
+  expectTypeOf<Organization<true, boolean>>().toEqualTypeOf<
+    OrganizationBase & {members: OrganizationMember[]} & {features?: string[]}
+  >()
+  expectTypeOf<Pick<Organization<true, boolean>, 'features'>>().toEqualTypeOf<{
+    features?: string[]
+  }>()
+})
+
+test('Organization — both wide booleans make both fields optional', () => {
+  expectTypeOf<Organization<boolean, boolean>>().toEqualTypeOf<
+    OrganizationBase & {members?: OrganizationMember[]} & {features?: string[]}
+  >()
+})

package/src/organization/organization.test.ts

@@ -0,0 +1,138 @@
+import {type SanityClient} from '@sanity/client'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, it} from 'vitest'
+
+import {getClientState} from '../client/clientStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getOrganizationCacheKey, resolveOrganization} from './organization'
+
+vi.mock('../client/clientStore')
+
+describe('organization', () => {
+  let instance: SanityInstance
+
+  beforeEach(() => {
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('calls `client.observable.request` against `/organizations/<id>` and returns the result', async () => {
+    const organization = {id: 'org_1'}
+    const request = vi.fn().mockReturnValue(of(organization))
+
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    const result = await resolveOrganization(instance, {organizationId: 'org_1'})
+    expect(result).toEqual(organization)
+    expect(request).toHaveBeenCalledWith({
+      uri: '/organizations/org_1',
+      query: {includeMembers: 'false', includeFeatures: 'false'},
+      tag: 'organization.get',
+    })
+  })
+
+  it('serializes query params (booleans → strings) and respects flags', async () => {
+    const request = vi.fn().mockReturnValue(of({id: 'org_1'}))
+    const mockClient = {
+      observable: {request} as unknown as SanityClient['observable'],
+    } as SanityClient
+
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of(mockClient),
+    } as StateSource<SanityClient>)
+
+    await resolveOrganization(instance, {
+      organizationId: 'org_1',
+      includeMembers: true,
+      includeFeatures: true,
+    })
+
+    expect(request).toHaveBeenCalledWith({
+      uri: '/organizations/org_1',
+      query: {
+        includeMembers: 'true',
+        includeFeatures: 'true',
+      },
+      tag: 'organization.get',
+    })
+  })
+
+  it('throws when no organizationId is provided', async () => {
+    await expect(resolveOrganization(instance, {organizationId: ''} as never)).rejects.toThrow(
+      'An organizationId is required to use the organization API.',
+    )
+  })
+})
+
+describe('organization cache key generation', () => {
+  let instance: SanityInstance
+
+  beforeEach(() => {
+    instance = createSanityInstance({})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('default call excludes :members and :features (both default-false)', () => {
+    expect(getOrganizationCacheKey(instance, {organizationId: 'org_1'})).toBe('organization:org_1')
+  })
+
+  it('treats undefined and the matching default as the same key', () => {
+    expect(getOrganizationCacheKey(instance, {organizationId: 'org_1'})).toBe(
+      getOrganizationCacheKey(instance, {
+        organizationId: 'org_1',
+        includeMembers: false,
+        includeFeatures: false,
+      }),
+    )
+  })
+
+  it('explicit includeMembers: true appends :members', () => {
+    expect(getOrganizationCacheKey(instance, {organizationId: 'org_1', includeMembers: true})).toBe(
+      'organization:org_1:members',
+    )
+  })
+
+  it('explicit includeFeatures: true appends :features', () => {
+    expect(
+      getOrganizationCacheKey(instance, {organizationId: 'org_1', includeFeatures: true}),
+    ).toBe('organization:org_1:features')
+  })
+
+  it('combines all segments in order', () => {
+    expect(
+      getOrganizationCacheKey(instance, {
+        organizationId: 'org_1',
+        includeMembers: true,
+        includeFeatures: true,
+      }),
+    ).toBe('organization:org_1:members:features')
+  })
+
+  it('produces distinct keys for each meaningful option permutation', () => {
+    const keys = new Set([
+      getOrganizationCacheKey(instance, {organizationId: 'org_1'}),
+      getOrganizationCacheKey(instance, {organizationId: 'org_1', includeMembers: true}),
+      getOrganizationCacheKey(instance, {organizationId: 'org_1', includeFeatures: true}),
+      getOrganizationCacheKey(instance, {
+        organizationId: 'org_1',
+        includeMembers: true,
+        includeFeatures: true,
+      }),
+      getOrganizationCacheKey(instance, {organizationId: 'org_2'}),
+    ])
+    expect(keys.size).toBe(5)
+  })
+})

package/src/organization/organization.ts

@@ -0,0 +1,166 @@
+import {switchMap} from 'rxjs'
+
+import {getClientState} from '../client/clientStore'
+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 OrganizationMember {
+  sanityUserId: string
+  isCurrentUser: boolean
+  user: {
+    id: string
+    displayName: string
+    familyName: string
+    givenName: string
+    middleName: string | null
+    imageUrl: string | null
+    email: string
+    loginProvider: string
+  }
+  roles: Array<{
+    name: string
+    title: string
+    description?: string
+  }>
+}
+
+/**
+ * The base fields returned from `/organizations/<id>` for every organization.
+ * @public
+ */
+export interface OrganizationBase {
+  id: string
+  name: string
+  slug: string | null
+  createdAt: string
+  createdByUserId: string
+  updatedAt: string
+  deletedAt: string | null
+  dashboardStatus: 'enabled' | 'disabled'
+  aiFeaturesStatus: 'enabled' | 'disabled'
+  mediaLibraryStatus: 'enabled' | 'disabled'
+  requestAccessStatus: 'allowed' | 'disabled'
+  telemetryConsentStatus: 'allowed' | 'msa_denied' | 'customer_denied'
+  oauthAppsStatus: 'allowed' | 'blocked'
+  defaultRoleName: string
+  domains: string[] | null
+}
+
+/** @public */
+export interface OrganizationOptions<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+> {
+  includeMembers?: IncludeMembers
+  includeFeatures?: IncludeFeatures
+  organizationId: string
+}
+
+/**
+ * An `Organization` with `members` and/or `features` conditionally included
+ * based on the query options used to fetch it.
+ * @public
+ */
+export type Organization<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+> = OrganizationBase &
+  // `boolean extends T` is non-distributive — true only when T is the wide
+  // `boolean`, in which case the field is optional. Literal `true`/`false`
+  // fall through to the strict branch.
+  (boolean extends IncludeMembers
+    ? {members?: OrganizationMember[]}
+    : IncludeMembers extends true
+      ? {members: OrganizationMember[]}
+      : unknown) &
+  (boolean extends IncludeFeatures
+    ? {features?: string[]}
+    : IncludeFeatures extends true
+      ? {features: string[]}
+      : unknown)
+
+function resolveOrganizationId(options?: OrganizationOptions<boolean, boolean>) {
+  const organizationId = options?.organizationId
+  if (!organizationId) {
+    throw new Error('An organizationId is required to use the organization API.')
+  }
+  return organizationId
+}
+
+function normalizeOrganizationOptions(options?: OrganizationOptions<boolean, boolean>) {
+  return {
+    includeMembers: options?.includeMembers ?? false,
+    includeFeatures: options?.includeFeatures ?? false,
+  }
+}
+
+/** @internal */
+export function getOrganizationCacheKey(
+  _instance: SanityInstance,
+  options?: OrganizationOptions<boolean, boolean>,
+): string {
+  const organizationId = resolveOrganizationId(options)
+  const {includeMembers, includeFeatures} = normalizeOrganizationOptions(options)
+  const membersKey = includeMembers ? ':members' : ''
+  const featuresKey = includeFeatures ? ':features' : ''
+  return `organization:${organizationId}${membersKey}${featuresKey}`
+}
+
+const organization = createFetcherStore({
+  name: 'Organization',
+  getKey: getOrganizationCacheKey,
+  fetcher: (instance) => (options?: OrganizationOptions<boolean, boolean>) => {
+    const organizationId = resolveOrganizationId(options)
+
+    return getClientState(instance, {
+      apiVersion: API_VERSION,
+      scope: 'global',
+    }).observable.pipe(
+      switchMap((client) => {
+        const normalized = normalizeOrganizationOptions(options)
+        const query = Object.fromEntries(
+          Object.entries(normalized)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, String(value)]),
+        )
+
+        return client.observable.request({
+          uri: `/organizations/${organizationId}`,
+          query,
+          tag: 'organization.get',
+        })
+      }),
+    )
+  },
+})
+
+/**
+ * Public signature for the organization 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 GetOrganizationState = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
+  instance: SanityInstance,
+  options: OrganizationOptions<IncludeMembers, IncludeFeatures>,
+) => StateSource<Organization<IncludeMembers, IncludeFeatures> | undefined>
+
+type ResolveOrganization = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
+  instance: SanityInstance,
+  options: OrganizationOptions<IncludeMembers, IncludeFeatures>,
+) => Promise<Organization<IncludeMembers, IncludeFeatures>>
+
+/** @public */
+export const getOrganizationState: GetOrganizationState = organization.getState
+
+/** @public */
+export const resolveOrganization: ResolveOrganization = organization.resolveState

package/src/organizations/organizations.test-d.ts

@@ -0,0 +1,77 @@
+import {expectTypeOf, test} from 'vitest'
+
+import {type OrganizationMember} from '../organization/organization'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getOrganizationsState, type Organizations, resolveOrganizations} from './organizations'
+
+const instance = {} as SanityInstance
+
+test('resolveOrganizations — default call: bare list shape', () => {
+  expectTypeOf(resolveOrganizations(instance)).resolves.toEqualTypeOf<Organizations<false, false>>()
+})
+
+test('resolveOrganizations — includeMembers: true narrows the generic', () => {
+  expectTypeOf(resolveOrganizations(instance, {includeMembers: true})).resolves.toEqualTypeOf<
+    Organizations<true, false>
+  >()
+})
+
+test('resolveOrganizations — includeFeatures: true narrows the generic', () => {
+  expectTypeOf(resolveOrganizations(instance, {includeFeatures: true})).resolves.toEqualTypeOf<
+    Organizations<false, true>
+  >()
+})
+
+test('resolveOrganizations — both flags true', () => {
+  expectTypeOf(
+    resolveOrganizations(instance, {includeMembers: true, includeFeatures: true}),
+  ).resolves.toEqualTypeOf<Organizations<true, true>>()
+})
+
+test('resolveOrganizations — rejects non-boolean flag values', () => {
+  // @ts-expect-error — includeMembers must be a boolean
+  void resolveOrganizations(instance, {includeMembers: 'yes'})
+})
+
+test('resolveOrganizations — includeImplicitMemberships does not change the data shape', () => {
+  expectTypeOf(
+    resolveOrganizations(instance, {includeImplicitMemberships: true}),
+  ).resolves.toEqualTypeOf<Organizations<false, false>>()
+})
+
+test('Organizations — list items expose the documented subset of keys', () => {
+  type Keys = keyof Organizations<false, false>[number]
+  expectTypeOf<Keys>().toEqualTypeOf<
+    | 'id'
+    | 'name'
+    | 'slug'
+    | 'createdAt'
+    | 'updatedAt'
+    | 'defaultRoleName'
+    | 'dashboardStatus'
+    | 'aiFeaturesStatus'
+  >()
+})
+
+test('Organizations<true, false>[number] exposes members[]', () => {
+  type Item = Organizations<true, false>[number]
+  expectTypeOf<Item['members']>().toEqualTypeOf<OrganizationMember[]>()
+})
+
+test('Organizations<false, true>[number] exposes features[]', () => {
+  type Item = Organizations<false, true>[number]
+  expectTypeOf<Item['features']>().toEqualTypeOf<string[]>()
+})
+
+test('Organizations<true, true>[number] exposes both members[] and features[]', () => {
+  type Item = Organizations<true, true>[number]
+  expectTypeOf<Item['members']>().toEqualTypeOf<OrganizationMember[]>()
+  expectTypeOf<Item['features']>().toEqualTypeOf<string[]>()
+})
+
+test('getOrganizationsState — default call returns the bare-base StateSource', () => {
+  expectTypeOf(getOrganizationsState(instance)).toEqualTypeOf<
+    StateSource<Organizations<false, false> | undefined>
+  >()
+})