@sanity/sdk-react 2.18.0 → 3.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "2.18.0",
+  "version": "3.0.0-rc.1",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
@@ -44,19 +44,21 @@
     "access": "public"
   },
   "dependencies": {
-    "@sanity/client": "^7.23.1",
+    "@sanity/client": "^7.23.2",
     "@sanity/message-protocol": "^0.23.0",
-    "@sanity/types": "^6.2.0",
+    "@sanity/types": "^6.5.0",
+    "@sanity/workbench": "0.1.0-alpha.24",
     "groq": "3.88.1-typegen-experimental.0",
     "react-compiler-runtime": "^1.0.0",
     "react-error-boundary": "^6.1.2",
     "rxjs": "^7.8.2",
-    "@sanity/sdk": "2.18.0"
+    "xstate": "^5.31.0",
+    "@sanity/sdk": "3.0.0-rc.1"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
     "@sanity/comlink": "^4.0.1",
-    "@sanity/pkg-utils": "^10.5.8",
+    "@sanity/pkg-utils": "^10.9.2",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^24.13.3",
@@ -66,20 +68,20 @@
     "@vitest/coverage-v8": "^4.1.10",
     "babel-plugin-react-compiler": "^1.0.0",
     "eslint": "^10.6.0",
-    "groq-js": "^1.30.3",
+    "groq-js": "^2.0.0",
     "jsdom": "^29.1.1",
     "oxfmt": "^0.58.0",
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "rollup-plugin-visualizer": "^7.0.1",
     "typescript": "^6.0.3",
-    "vite": "^8.1.4",
+    "vite": "^8.1.5",
     "vitest": "^4.1.10",
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
     "@repo/package.bundle": "3.82.0",
-    "@repo/tsconfig": "0.0.1",
-    "@repo/package.config": "0.0.1"
+    "@repo/package.config": "0.0.1",
+    "@repo/tsconfig": "0.0.1"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",

package/src/_exports/sdk-react.ts

@@ -13,6 +13,7 @@ export {
   type SanityInstanceProviderProps,
 } from '../context/SanityInstanceProvider'
 export {SDKStudioContext, type StudioWorkspaceHandle} from '../context/SDKStudioContext'
+export {useCheckPermissions} from '../hooks/access/useCheckPermissions'
 export {
   useAgentGenerate,
   useAgentPatch,
@@ -24,6 +25,15 @@ export {
   type AgentResourceContextOptions,
   useAgentResourceContext,
 } from '../hooks/agent/useAgentResourceContext'
+export {useApplication} from '../hooks/applications/useApplication'
+export {useApplications} from '../hooks/applications/useApplications'
+export {useCreateUserApplication} from '../hooks/applications/useCreateUserApplication'
+export {useDeleteApplication} from '../hooks/applications/useDeleteApplication'
+export {useDeleteUserApplication} from '../hooks/applications/useDeleteUserApplication'
+export {useUpdateApplication} from '../hooks/applications/useUpdateApplication'
+export {useUpdateUserApplication} from '../hooks/applications/useUpdateUserApplication'
+export {useUserApplication} from '../hooks/applications/useUserApplication'
+export {useUserApplications} from '../hooks/applications/useUserApplications'
 export {useAuthState} from '../hooks/auth/useAuthState'
 export {useAuthToken} from '../hooks/auth/useAuthToken'
 export {useCurrentUser} from '../hooks/auth/useCurrentUser'
@@ -48,7 +58,6 @@ export {
 export {useResource} from '../hooks/context/useResource'
 export {useSanityInstance} from '../hooks/context/useSanityInstance'
 export {useDashboardNavigate} from '../hooks/dashboard/useDashboardNavigate'
-export {useDispatchIntent} from '../hooks/dashboard/useDispatchIntent'
 export {useManageFavorite} from '../hooks/dashboard/useManageFavorite'
 export {
   type NavigateToStudioResult,
@@ -70,6 +79,10 @@ export {
   type DocumentsResponse,
   useDocuments,
 } from '../hooks/documents/useDocuments'
+export {type FetcherHookResult} from '../hooks/helpers/createFetcherHook'
+export {type MutationHookResult} from '../hooks/helpers/createMutationHook'
+export {useInstallation} from '../hooks/installations/useInstallation'
+export {useInstallations} from '../hooks/installations/useInstallations'
 export {useOrganization} from '../hooks/organizations/useOrganization'
 export {useOrganizations} from '../hooks/organizations/useOrganizations'
 export {

package/src/components/auth/AuthBoundary.tsx

@@ -4,6 +4,8 @@ import {useEffect, useMemo} from 'react'
 import {ErrorBoundary, type FallbackProps} from 'react-error-boundary'
 
 import {ComlinkTokenRefreshProvider} from '../../context/ComlinkTokenRefresh'
+import {isWorkbenchEnvironment} from '../../context/workbenchToken'
+import {WorkbenchTokenRefreshProvider} from '../../context/WorkbenchTokenRefresh'
 import {useAuthState} from '../../hooks/auth/useAuthState'
 import {useLoginUrl} from '../../hooks/auth/useLoginUrl'
 import {useVerifyOrgProjects} from '../../hooks/auth/useVerifyOrgProjects'
@@ -141,9 +143,11 @@ export function AuthBoundary({
 
   return (
     <ComlinkTokenRefreshProvider>
-      <ErrorBoundary FallbackComponent={FallbackComponent} resetKeys={[sessionResetKey]}>
-        <AuthSwitch {...props} />
-      </ErrorBoundary>
+      <WorkbenchTokenRefreshProvider>
+        <ErrorBoundary FallbackComponent={FallbackComponent} resetKeys={[sessionResetKey]}>
+          <AuthSwitch {...props} />
+        </ErrorBoundary>
+      </WorkbenchTokenRefreshProvider>
     </ComlinkTokenRefreshProvider>
   )
 }
@@ -182,8 +186,9 @@ function AuthSwitch({
   const loginUrl = useLoginUrl()
 
   useEffect(() => {
-    if (isLoggedOut && !isInIframe() && !isStudio) {
-      // We don't want to redirect to login if we're in the Dashboard nor in studio mode
+    if (isLoggedOut && !isInIframe() && !isStudio && !isWorkbenchEnvironment()) {
+      // We don't want to redirect to login if we're in the Dashboard, in studio
+      // mode, or in the workbench (the OS owns the session and mints the token)
       window.location.href = loginUrl
     }
   }, [isLoggedOut, loginUrl, isStudio])

package/src/context/WorkbenchTokenRefresh.test.tsx

@@ -0,0 +1,106 @@
+import {AuthStateType, setAuthToken} from '@sanity/sdk'
+import {act, render} from '@testing-library/react'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {useAuthState} from '../hooks/auth/useAuthState'
+import {ResourceProvider} from './ResourceProvider'
+import {
+  isWorkbenchEnvironment,
+  observeWorkbenchToken,
+  refreshWorkbenchToken,
+} from './workbenchToken'
+import {WorkbenchTokenRefreshProvider} from './WorkbenchTokenRefresh'
+
+vi.mock('@sanity/sdk', async () => {
+  const actual = await vi.importActual('@sanity/sdk')
+  return {
+    ...actual,
+    setAuthToken: vi.fn(),
+  }
+})
+
+vi.mock('../hooks/auth/useAuthState', () => ({
+  useAuthState: vi.fn(),
+}))
+
+vi.mock('./workbenchToken', () => ({
+  isWorkbenchEnvironment: vi.fn(() => false),
+  observeWorkbenchToken: vi.fn(() => undefined),
+  refreshWorkbenchToken: vi.fn(),
+}))
+
+const mockSetAuthToken = setAuthToken as Mock
+const mockUseAuthState = useAuthState as Mock
+const mockIsWorkbenchEnvironment = isWorkbenchEnvironment as Mock
+const mockObserveWorkbenchToken = observeWorkbenchToken as Mock
+const mockRefreshWorkbenchToken = refreshWorkbenchToken as Mock
+
+const renderProvider = () =>
+  render(
+    <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+      <WorkbenchTokenRefreshProvider>
+        <div>Test</div>
+      </WorkbenchTokenRefreshProvider>
+    </ResourceProvider>,
+  )
+
+describe('WorkbenchTokenRefreshProvider', () => {
+  beforeEach(() => {
+    mockUseAuthState.mockReturnValue({type: AuthStateType.LOGGED_IN})
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('when not in the workbench', () => {
+    it('does not subscribe to the OS token', () => {
+      mockIsWorkbenchEnvironment.mockReturnValue(false)
+
+      act(() => {
+        renderProvider()
+      })
+
+      expect(mockSetAuthToken).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('when in the workbench', () => {
+    beforeEach(() => {
+      mockIsWorkbenchEnvironment.mockReturnValue(true)
+    })
+
+    it('mirrors the OS token into the auth store', () => {
+      mockObserveWorkbenchToken.mockReturnValue(of('workbench-token'))
+
+      act(() => {
+        renderProvider()
+      })
+
+      expect(mockSetAuthToken).toHaveBeenCalledWith(expect.anything(), 'workbench-token')
+    })
+
+    it('asks the OS to reissue the token on a 401', () => {
+      mockObserveWorkbenchToken.mockReturnValue(of('workbench-token'))
+
+      const {rerender} = renderProvider()
+
+      mockUseAuthState.mockReturnValue({
+        type: AuthStateType.ERROR,
+        error: {statusCode: 401, message: 'Unauthorized'},
+      })
+      act(() => {
+        rerender(
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+            <WorkbenchTokenRefreshProvider>
+              <div>Test</div>
+            </WorkbenchTokenRefreshProvider>
+          </ResourceProvider>,
+        )
+      })
+
+      expect(mockRefreshWorkbenchToken).toHaveBeenCalledTimes(1)
+    })
+  })
+})

package/src/context/WorkbenchTokenRefresh.tsx

@@ -0,0 +1,61 @@
+import {type ClientError} from '@sanity/client'
+import {AuthStateType, setAuthToken} from '@sanity/sdk'
+import React, {type PropsWithChildren, useEffect, useRef} from 'react'
+
+import {useAuthState} from '../hooks/auth/useAuthState'
+import {useSanityInstance} from '../hooks/context/useSanityInstance'
+import {
+  isWorkbenchEnvironment,
+  observeWorkbenchToken,
+  refreshWorkbenchToken,
+} from './workbenchToken'
+
+/**
+ * Keeps the SDK auth token in sync with the workbench "OS".
+ *
+ * When running as a federated remote inside the workbench the OS owns the
+ * session, so we subscribe to its `auth.token` stream and mirror each value into
+ * the auth store — a token logs us in, `null` logs us out, and later OS
+ * sign-in/out propagates automatically. When a request is rejected with a 401
+ * (the token expired), we ask the OS to reissue rather than tearing the session
+ * down; the new token arrives back through the same subscription.
+ */
+function WorkbenchTokenRefresh({children}: PropsWithChildren) {
+  const instance = useSanityInstance()
+  const authState = useAuthState()
+  const processed401ErrorRef = useRef<unknown | null>(null)
+
+  useEffect(() => {
+    const token$ = observeWorkbenchToken()
+    if (!token$) return undefined
+    const subscription = token$.subscribe((token) => setAuthToken(instance, token))
+    return () => subscription.unsubscribe()
+  }, [instance])
+
+  useEffect(() => {
+    const has401Error =
+      authState.type === AuthStateType.ERROR && (authState.error as ClientError)?.statusCode === 401
+
+    if (has401Error && processed401ErrorRef.current !== authState.error) {
+      processed401ErrorRef.current = authState.error
+      refreshWorkbenchToken()
+    } else if (!has401Error) {
+      processed401ErrorRef.current = null
+    }
+  }, [authState])
+
+  return children
+}
+
+/**
+ * Provides workbench OS token refresh. No-op outside the workbench, where the
+ * app uses its normal auth flow.
+ * @public
+ */
+export const WorkbenchTokenRefreshProvider: React.FC<PropsWithChildren> = ({children}) => {
+  if (isWorkbenchEnvironment()) {
+    return <WorkbenchTokenRefresh>{children}</WorkbenchTokenRefresh>
+  }
+
+  return children
+}

package/src/context/workbenchToken.ts

@@ -0,0 +1,63 @@
+import {from, type Observable, of} from 'rxjs'
+import {catchError, switchMap} from 'rxjs/operators'
+
+// The workbench host installs its shared message bus on this well-known global
+// symbol before it loads federated remotes. It must match the key used by
+// `@sanity/workbench` (`Symbol.for('sanity.os.bus')`).
+const OS_BUS_KEY = Symbol.for('sanity.os.bus')
+
+/**
+ * Whether this app is running as a federated remote inside the workbench.
+ *
+ * Federation shares the host's realm, so the installed bus is visible on
+ * `globalThis`. This is `false` in a standalone app, where we must never import
+ * `@sanity/workbench` (it would install a bus and add bundle weight for no
+ * reason). Note: this is a different embedding model to the Core UI iframe,
+ * which is detected separately via the dashboard context — that signal is not
+ * set on the federation path.
+ *
+ * @internal
+ */
+export function isWorkbenchEnvironment(): boolean {
+  return typeof globalThis === 'object' && OS_BUS_KEY in globalThis
+}
+
+/**
+ * Observes the session token issued by the workbench "OS", tracking the OS auth
+ * state over time.
+ *
+ * Returns `undefined` when the app is not embedded in the workbench, so the
+ * caller uses its normal auth flow. Inside the workbench, subscribes to the
+ * `auth.token` state topic, emitting the current token — or `null` when the OS
+ * is signed out — and re-emitting as the OS auth state changes, so sign-in/out
+ * propagates instead of being captured once. Any bus error is treated as "no
+ * token" (`null`). The token is used in-memory only and never persisted.
+ *
+ * @internal
+ */
+export function observeWorkbenchToken(): Observable<string | null> | undefined {
+  if (!isWorkbenchEnvironment()) return undefined
+
+  return from(import('@sanity/workbench')).pipe(
+    switchMap(({os}) => os.subscribe('auth.token')),
+    // Any failure (importing the host bundle, or the subscription) means "no OS token".
+    catchError(() => of(null)),
+  )
+}
+
+/**
+ * Asks the workbench "OS" to reissue the session token, e.g. after its current
+ * one was rejected with a 401. Fire-and-forget: the reissued token arrives via
+ * the `auth.token` subscription in {@link observeWorkbenchToken}. No-op outside
+ * the workbench.
+ *
+ * @internal
+ */
+export function refreshWorkbenchToken(): void {
+  if (!isWorkbenchEnvironment()) return
+
+  void import('@sanity/workbench').then(
+    ({os}) => os.emit('auth.token.refresh', undefined),
+    () => {},
+  )
+}

package/src/hooks/access/useCheckPermissions.test-d.ts

@@ -0,0 +1,15 @@
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useCheckPermissions} from './useCheckPermissions'
+
+test('useCheckPermissions — the result is keyed by exactly the permissions passed', () => {
+  const result = useCheckPermissions('project', 'proj_1', ['read', 'write'])
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<Record<'read' | 'write', boolean>>>()
+  expectTypeOf(result.data).toEqualTypeOf<Record<'read' | 'write', boolean>>()
+})
+
+test('useCheckPermissions — rejects an unknown resource type', () => {
+  // @ts-expect-error — resourceType must be an AccessResourceType
+  void useCheckPermissions('not-a-resource', 'id', ['read'])
+})

package/src/hooks/access/useCheckPermissions.test.tsx

@@ -0,0 +1,53 @@
+import {checkPermissions, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {type Observable} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {useCheckPermissions} from './useCheckPermissions'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    checkPermissions: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()},
+  }
+})
+
+const stateSource = (
+  current: Record<string, boolean>,
+): StateSource<FetcherSnapshot<Record<string, boolean>>> => {
+  const snapshot = {
+    status: 'success',
+    data: current,
+    error: undefined,
+    isFetching: false,
+    dataUpdatedAt: 1,
+  }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
+    get observable(): Observable<unknown> {
+      throw new Error('Not implemented')
+    },
+  } as unknown as StateSource<FetcherSnapshot<Record<string, boolean>>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
+
+describe('useCheckPermissions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(checkPermissions.getState).mockReturnValue(stateSource({'sanity.project.read': true}))
+  })
+
+  it('forwards every param to the fetcher and returns the permission map', () => {
+    const {result} = renderHook(() =>
+      useCheckPermissions('project', 'proj_1', ['sanity.project.read']),
+    )
+    expect(checkPermissions.getState).toHaveBeenCalledWith(sanityInstance, 'project', 'proj_1', [
+      'sanity.project.read',
+    ])
+    expect(result.current.data).toEqual({'sanity.project.read': true})
+  })
+})

package/src/hooks/access/useCheckPermissions.ts

@@ -0,0 +1,24 @@
+import {type AccessResourceType, checkPermissions} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Checks whether the current user holds the given permissions on a resource.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * `data` maps each requested permission to whether the user has it — keyed by
+ * exactly the permission strings you passed.
+ *
+ * @public
+ * @param resourceType - The type of resource (e.g. `'project'`, `'organization'`).
+ * @param resourceId - The resource id.
+ * @param permissions - The permission names to check.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useCheckPermissions = createFetcherHook(checkPermissions) as <
+  Permission extends string,
+>(
+  resourceType: AccessResourceType,
+  resourceId: string,
+  permissions: Permission[],
+) => FetcherHookResult<Record<Permission, boolean>>

package/src/hooks/applications/useApplication.test-d.ts

@@ -0,0 +1,30 @@
+import {
+  type Application,
+  type ApplicationDeployment,
+  type ApplicationStudioConfig,
+} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useApplication} from './useApplication'
+
+test('useApplication — no include: the base application', () => {
+  const result = useApplication('app_1')
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<Application<never>>>()
+  expectTypeOf<
+    Extract<keyof typeof result.data, 'activeDeployment' | 'config'>
+  >().toEqualTypeOf<never>()
+})
+
+test('useApplication — config.studio include adds config.studio', () => {
+  const result = useApplication('app_1', {include: ['config.studio']})
+  expectTypeOf(result.data).toEqualTypeOf<Application<'config.studio'>>()
+  expectTypeOf(result.data.config.studio).toEqualTypeOf<ApplicationStudioConfig>()
+})
+
+test('useApplication — a deployment-child include forces the deployment in', () => {
+  const result = useApplication('app_1', {include: ['activeDeployment']})
+  expectTypeOf(
+    result.data.activeDeployment,
+  ).toEqualTypeOf<ApplicationDeployment<'activeDeployment'> | null>()
+})

package/src/hooks/applications/useApplication.ts

@@ -0,0 +1,22 @@
+import {type Application, application, type ApplicationInclude} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Returns a single application by id.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param applicationId - The application id.
+ * @param options - Optional `include` list to expand related resources.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useApplication = createFetcherHook(application) as <
+  Include extends ApplicationInclude = never,
+>(
+  applicationId: string,
+  options?: {include?: Include[]},
+) => FetcherHookResult<Application<Include>>

package/src/hooks/applications/useApplications.test-d.ts

@@ -0,0 +1,31 @@
+import {type Application, type ApplicationInterface, type ApplicationsResponse} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useApplications} from './useApplications'
+
+test('useApplications — no include: base items, no deployment or config', () => {
+  const result = useApplications({organizationId: 'org_1'})
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<ApplicationsResponse<never>>>()
+  type Item = (typeof result.data.data)[number]
+  expectTypeOf<Extract<keyof Item, 'activeDeployment' | 'config'>>().toEqualTypeOf<never>()
+})
+
+test('useApplications — include shapes each item', () => {
+  const result = useApplications({organizationId: 'org_1', include: ['interfaces']})
+  expectTypeOf(result.data).toEqualTypeOf<ApplicationsResponse<'interfaces'>>()
+  type Item = (typeof result.data.data)[number]
+  expectTypeOf<NonNullable<Item['activeDeployment']>['interfaces']>().toEqualTypeOf<
+    ApplicationInterface[]
+  >()
+})
+
+test('useApplications — result data is the current include-narrowed application', () => {
+  const result = useApplications({organizationId: 'org_1', include: ['config.studio']})
+  expectTypeOf(result.data.data).toEqualTypeOf<Application<'config.studio'>[]>()
+})
+
+test('useApplications — requires an organizationId', () => {
+  // @ts-expect-error — organizationId is required
+  void useApplications({})
+})

package/src/hooks/applications/useApplications.ts

@@ -0,0 +1,25 @@
+import {
+  type ApplicationInclude,
+  applications,
+  type ApplicationsOptions,
+  type ApplicationsResponse,
+} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Returns the applications matching the given options.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data.data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param options - Filter and include options for the applications list.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useApplications = createFetcherHook(applications) as <
+  Include extends ApplicationInclude = never,
+>(
+  options: ApplicationsOptions<Include>,
+) => FetcherHookResult<ApplicationsResponse<Include>>

package/src/hooks/applications/useCreateUserApplication.test-d.ts

@@ -0,0 +1,14 @@
+import {type CreateUserApplicationInput, type UserApplication} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type MutationHookResult} from '../helpers/createMutationHook'
+import {useCreateUserApplication} from './useCreateUserApplication'
+
+test('useCreateUserApplication — returns the mutation envelope', () => {
+  const result = useCreateUserApplication()
+  expectTypeOf(result).toEqualTypeOf<
+    MutationHookResult<CreateUserApplicationInput, UserApplication>
+  >()
+  expectTypeOf(result.mutate).parameter(0).toEqualTypeOf<CreateUserApplicationInput>()
+  expectTypeOf(result.data).toEqualTypeOf<UserApplication | undefined>()
+})

package/src/hooks/applications/useCreateUserApplication.ts

@@ -0,0 +1,11 @@
+import {createUserApplication} from '@sanity/sdk'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+
+/**
+ * Creates a user application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export const useCreateUserApplication = createMutationHook(createUserApplication)

package/src/hooks/applications/useDeleteApplication.test-d.ts

@@ -0,0 +1,12 @@
+import {type DeleteApplicationInput, type DeletedResult} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type MutationHookResult} from '../helpers/createMutationHook'
+import {useDeleteApplication} from './useDeleteApplication'
+
+test('useDeleteApplication — returns the mutation envelope', () => {
+  const result = useDeleteApplication()
+  expectTypeOf(result).toEqualTypeOf<MutationHookResult<DeleteApplicationInput, DeletedResult>>()
+  expectTypeOf(result.mutate).parameter(0).toEqualTypeOf<DeleteApplicationInput>()
+  expectTypeOf(result.data).toEqualTypeOf<DeletedResult | undefined>()
+})

package/src/hooks/applications/useDeleteApplication.ts

@@ -0,0 +1,11 @@
+import {deleteApplication} from '@sanity/sdk'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+
+/**
+ * Soft-deletes an application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export const useDeleteApplication = createMutationHook(deleteApplication)

package/src/hooks/applications/useDeleteUserApplication.test-d.ts

@@ -0,0 +1,14 @@
+import {type DeletedResult, type DeleteUserApplicationInput} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type MutationHookResult} from '../helpers/createMutationHook'
+import {useDeleteUserApplication} from './useDeleteUserApplication'
+
+test('useDeleteUserApplication — returns the mutation envelope', () => {
+  const result = useDeleteUserApplication()
+  expectTypeOf(result).toEqualTypeOf<
+    MutationHookResult<DeleteUserApplicationInput, DeletedResult>
+  >()
+  expectTypeOf(result.mutate).parameter(0).toEqualTypeOf<DeleteUserApplicationInput>()
+  expectTypeOf(result.data).toEqualTypeOf<DeletedResult | undefined>()
+})

package/src/hooks/applications/useDeleteUserApplication.ts

@@ -0,0 +1,11 @@
+import {deleteUserApplication} from '@sanity/sdk'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+
+/**
+ * Deletes a user application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export const useDeleteUserApplication = createMutationHook(deleteUserApplication)