@sanity/sdk 2.10.0 → 2.11.1

package/src/document/processActions/publish.ts

@@ -0,0 +1,120 @@
+import {DocumentId, getDraftId, getPublishedId} from '@sanity/id-utils'
+import {type Mutation, type Reference, type SanityDocument} from '@sanity/types'
+
+import {isReleasePerspective} from '../../releases/utils/isReleasePerspective'
+import {isDeepEqual} from '../../utils/object'
+import {type PublishDocumentAction} from '../actions'
+import {getId, processMutations} from '../processMutations'
+import {
+  ActionError,
+  type ActionHandlerContext,
+  type ActionHandlerResult,
+  checkGrant,
+  PermissionActionError,
+} from './shared'
+
+export function handlePublish(
+  action: PublishDocumentAction,
+  ctx: ActionHandlerContext,
+): ActionHandlerResult {
+  const {transactionId, timestamp, grants, outgoingActions, outgoingMutations} = ctx
+  let {base, working} = ctx
+
+  const documentId = getId(action.documentId)
+
+  if (action.liveEdit || isReleasePerspective(action.perspective)) {
+    throw new ActionError({
+      documentId,
+      transactionId,
+      message: `Cannot publish this document. Publishing is not supported for liveEdit or version (release) documents.`,
+    })
+  }
+
+  // Standard draft/published logic
+  const draftId = getDraftId(DocumentId(documentId))
+  const publishedId = getPublishedId(DocumentId(documentId))
+
+  const workingDraft = working[draftId]
+  const baseDraft = base[draftId]
+  if (!workingDraft || !baseDraft) {
+    throw new ActionError({
+      documentId,
+      transactionId,
+      message: `Cannot publish because no draft version was found for document "${documentId}".`,
+    })
+  }
+
+  // Before proceeding, verify that the working draft is identical to the base draft.
+  // TODO: is it enough just to check for the _rev or nah?
+  if (!isDeepEqual(workingDraft, baseDraft)) {
+    throw new ActionError({
+      documentId,
+      transactionId,
+      message: `Publish aborted: The document has changed elsewhere. Please try again.`,
+    })
+  }
+
+  const newPublishedFromDraft = {...strengthenOnPublish(workingDraft), _id: publishedId}
+
+  const mutations: Mutation[] = [{delete: {id: draftId}}, {createOrReplace: newPublishedFromDraft}]
+
+  if (working[draftId] && !checkGrant(grants.update, working[draftId])) {
+    throw new PermissionActionError({
+      documentId,
+      transactionId,
+      message: `Publish failed: You do not have permission to update the draft for "${documentId}".`,
+    })
+  }
+
+  if (working[publishedId] && !checkGrant(grants.update, newPublishedFromDraft)) {
+    throw new PermissionActionError({
+      documentId,
+      transactionId,
+      message: `Publish failed: You do not have permission to update the published version of "${documentId}".`,
+    })
+  } else if (!working[publishedId] && !checkGrant(grants.create, newPublishedFromDraft)) {
+    throw new PermissionActionError({
+      documentId,
+      transactionId,
+      message: `Publish failed: You do not have permission to publish a new version of "${documentId}".`,
+    })
+  }
+
+  base = processMutations({documents: base, transactionId, mutations, timestamp})
+  working = processMutations({documents: working, transactionId, mutations, timestamp})
+
+  outgoingMutations.push(...mutations)
+  outgoingActions.push({
+    actionType: 'sanity.action.document.publish',
+    draftId,
+    publishedId,
+  })
+  return {base, working}
+}
+
+function strengthenOnPublish(draft: SanityDocument): SanityDocument {
+  const isStrengthenReference = (
+    value: object,
+  ): value is Reference & Required<Pick<Reference, '_strengthenOnPublish'>> =>
+    '_strengthenOnPublish' in value
+
+  function strengthen(value: unknown): unknown {
+    if (typeof value !== 'object' || !value) return value
+
+    if (isStrengthenReference(value)) {
+      const {_strengthenOnPublish, _weak, ...rest} = value
+      return {
+        ...rest,
+        ...(_strengthenOnPublish.weak && {_weak: true}),
+      }
+    }
+
+    if (Array.isArray(value)) {
+      return value.map(strengthen)
+    }
+
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, strengthen(v)]))
+  }
+
+  return strengthen(draft) as SanityDocument
+}

package/src/document/processActions/shared.ts

@@ -0,0 +1,47 @@
+import {type Mutation, type SanityDocument} from '@sanity/types'
+import {evaluateSync, type ExprNode} from 'groq-js'
+
+import {type Grant} from '../permissions'
+import {type DocumentSet} from '../processMutations'
+import {type HttpAction} from '../reducers'
+
+export interface ActionHandlerContext {
+  base: DocumentSet
+  working: DocumentSet
+  transactionId: string
+  timestamp: string
+  grants: Record<Grant, ExprNode>
+  outgoingActions: HttpAction[]
+  outgoingMutations: Mutation[]
+}
+
+export interface ActionHandlerResult {
+  base: DocumentSet
+  working: DocumentSet
+}
+
+export function checkGrant(grantExpr: ExprNode, document: SanityDocument): boolean {
+  const value = evaluateSync(grantExpr, {params: {document}})
+  return value.type === 'boolean' && value.data
+}
+
+interface ActionErrorOptions {
+  message: string
+  documentId: string
+  transactionId: string
+}
+
+/**
+ * Thrown when a precondition for an action failed.
+ */
+export class ActionError extends Error implements ActionErrorOptions {
+  documentId!: string
+  transactionId!: string
+
+  constructor(options: ActionErrorOptions) {
+    super(options.message)
+    Object.assign(this, options)
+  }
+}
+
+export class PermissionActionError extends ActionError {}

package/src/document/processActions/unpublish.ts

@@ -0,0 +1,85 @@
+import {DocumentId, getDraftId, getPublishedId} from '@sanity/id-utils'
+import {type Mutation, type SanityDocument} from '@sanity/types'
+
+import {isReleasePerspective} from '../../releases/utils/isReleasePerspective'
+import {type UnpublishDocumentAction} from '../actions'
+import {getId, processMutations} from '../processMutations'
+import {
+  ActionError,
+  type ActionHandlerContext,
+  type ActionHandlerResult,
+  checkGrant,
+  PermissionActionError,
+} from './shared'
+
+export function handleUnpublish(
+  action: UnpublishDocumentAction,
+  ctx: ActionHandlerContext,
+): ActionHandlerResult {
+  const {transactionId, timestamp, grants, outgoingActions, outgoingMutations} = ctx
+  let {base, working} = ctx
+
+  const documentId = getId(action.documentId)
+
+  if (action.liveEdit || isReleasePerspective(action.perspective)) {
+    throw new ActionError({
+      documentId,
+      transactionId,
+      message: `Cannot unpublish this document. Unpublishing is not supported for liveEdit or version (release) documents.`,
+    })
+  }
+
+  // Standard draft/published or version logic
+  const draftId = getDraftId(DocumentId(documentId))
+  const publishedId = getPublishedId(DocumentId(documentId))
+
+  if (!working[publishedId] && !base[publishedId]) {
+    throw new ActionError({
+      documentId,
+      transactionId,
+      message: `Cannot unpublish because the document "${documentId}" is not currently published.`,
+    })
+  }
+
+  const sourceDoc = working[publishedId] ?? (base[publishedId] as SanityDocument)
+  const newDraftFromPublished = {...sourceDoc, _id: draftId}
+  const mutations: Mutation[] = [
+    {delete: {id: publishedId}},
+    {createIfNotExists: newDraftFromPublished},
+  ]
+
+  if (!checkGrant(grants.update, sourceDoc)) {
+    throw new PermissionActionError({
+      documentId,
+      transactionId,
+      message: `You do not have permission to unpublish the document "${documentId}".`,
+    })
+  }
+
+  if (!working[draftId] && !checkGrant(grants.create, newDraftFromPublished)) {
+    throw new PermissionActionError({
+      documentId,
+      transactionId,
+      message: `You do not have permission to create a draft from the published version of "${documentId}".`,
+    })
+  }
+
+  base = processMutations({
+    documents: base,
+    transactionId,
+    mutations: [
+      {delete: {id: publishedId}},
+      {createIfNotExists: {...(base[publishedId] ?? sourceDoc), _id: draftId}},
+    ],
+    timestamp,
+  })
+  working = processMutations({documents: working, transactionId, mutations, timestamp})
+
+  outgoingMutations.push(...mutations)
+  outgoingActions.push({
+    actionType: 'sanity.action.document.unpublish',
+    draftId,
+    publishedId,
+  })
+  return {base, working}
+}

package/src/document/processActions.test.ts

@@ -3,7 +3,7 @@ import {parse} from 'groq-js'
 import {describe, expect, it} from 'vitest'
 
 import {type DocumentAction} from './actions'
-import {ActionError, processActions} from './processActions'
+import {ActionError, processActions} from './processActions/processActions'
 import {type DocumentSet} from './processMutations'
 
 // Helper: Create a sample document that conforms to SanityDocument.

package/src/document/reducers.ts

@@ -11,7 +11,7 @@ import {type DocumentAction} from './actions'
 import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
 import {type DocumentState, type DocumentStoreState} from './documentStore'
 import {type RemoteDocument} from './listen'
-import {ActionError, processActions} from './processActions'
+import {ActionError, processActions} from './processActions/processActions'
 import {type DocumentSet} from './processMutations'
 
 const EMPTY_REVISIONS: NonNullable<Required<DocumentState['unverifiedRevisions']>> = {}

package/src/document/sharedListener.ts

@@ -14,7 +14,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DocumentResource, isDatasetResource} from '../config/sanityConfig'
+import {type DocumentResource} from '../config/sanityConfig'
 import {type SanityInstance} from '../store/createSanityInstance'
 
 const API_VERSION = 'v2025-05-06'
@@ -31,8 +31,7 @@ export function createSharedListener(
   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 resource
-    resource: resource && !isDatasetResource(resource) ? resource : undefined,
+    resource,
   }).observable.pipe(
     switchMap((client) =>
       // TODO: it seems like the client.listen method is not emitting disconnected
@@ -72,8 +71,7 @@ export function createFetchDocument(instance: SanityInstance, resource?: Documen
   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 resource
-      resource: resource && !isDatasetResource(resource) ? resource : 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)
+  })
+})