@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.1

package/src/agent/agentActions.ts

@@ -7,14 +7,6 @@ import {type SanityInstance} from '../store/createSanityInstance'
 
 const API_VERSION = 'vX'
 
-/**
- * Options that all agent actions accept for targeting a specific resource.
- * @alpha
- */
-export interface AgentResourceOptions {
-  resource: DocumentResource
-}
-
 /** @alpha */
 export type AgentGenerateOptions = Parameters<
   SanityClient['observable']['agent']['action']['generate']
@@ -66,13 +58,12 @@ export type AgentPatchResult = Awaited<ReturnType<SanityClient['agent']['action'
  */
 export function agentGenerate(
   instance: SanityInstance,
-  options: AgentGenerateOptions & AgentResourceOptions,
+  options: AgentGenerateOptions,
+  resource?: DocumentResource,
 ): AgentGenerateResult {
-  const {resource, ...agentOptions} = options
-  return getClientState(instance, {
-    apiVersion: API_VERSION,
-    resource,
-  }).observable.pipe(switchMap((client) => client.observable.agent.action.generate(agentOptions)))
+  return getClientState(instance, {apiVersion: API_VERSION, resource}).observable.pipe(
+    switchMap((client) => client.observable.agent.action.generate(options)),
+  )
 }
 
 /**
@@ -84,13 +75,12 @@ export function agentGenerate(
  */
 export function agentTransform(
   instance: SanityInstance,
-  options: AgentTransformOptions & AgentResourceOptions,
+  options: AgentTransformOptions,
+  resource?: DocumentResource,
 ): AgentTransformResult {
-  const {resource, ...agentOptions} = options
-  return getClientState(instance, {
-    apiVersion: API_VERSION,
-    resource,
-  }).observable.pipe(switchMap((client) => client.observable.agent.action.transform(agentOptions)))
+  return getClientState(instance, {apiVersion: API_VERSION, resource}).observable.pipe(
+    switchMap((client) => client.observable.agent.action.transform(options)),
+  )
 }
 
 /**
@@ -102,13 +92,12 @@ export function agentTransform(
  */
 export function agentTranslate(
   instance: SanityInstance,
-  options: AgentTranslateOptions & AgentResourceOptions,
+  options: AgentTranslateOptions,
+  resource?: DocumentResource,
 ): AgentTranslateResult {
-  const {resource, ...agentOptions} = options
-  return getClientState(instance, {
-    apiVersion: API_VERSION,
-    resource,
-  }).observable.pipe(switchMap((client) => client.observable.agent.action.translate(agentOptions)))
+  return getClientState(instance, {apiVersion: API_VERSION, resource}).observable.pipe(
+    switchMap((client) => client.observable.agent.action.translate(options)),
+  )
 }
 
 /**
@@ -120,13 +109,12 @@ export function agentTranslate(
  */
 export function agentPrompt(
   instance: SanityInstance,
-  options: AgentPromptOptions & AgentResourceOptions,
+  options: AgentPromptOptions,
+  resource?: DocumentResource,
 ): Observable<AgentPromptResult> {
-  const {resource, ...agentOptions} = options
-  return getClientState(instance, {
-    apiVersion: API_VERSION,
-    resource,
-  }).observable.pipe(switchMap((client) => from(client.agent.action.prompt(agentOptions))))
+  return getClientState(instance, {apiVersion: API_VERSION, resource}).observable.pipe(
+    switchMap((client) => from(client.agent.action.prompt(options))),
+  )
 }
 
 /**
@@ -138,11 +126,10 @@ export function agentPrompt(
  */
 export function agentPatch(
   instance: SanityInstance,
-  options: AgentPatchOptions & AgentResourceOptions,
+  options: AgentPatchOptions,
+  resource?: DocumentResource,
 ): Observable<AgentPatchResult> {
-  const {resource, ...agentOptions} = options
-  return getClientState(instance, {
-    apiVersion: API_VERSION,
-    resource,
-  }).observable.pipe(switchMap((client) => from(client.agent.action.patch(agentOptions))))
+  return getClientState(instance, {apiVersion: API_VERSION, resource}).observable.pipe(
+    switchMap((client) => from(client.agent.action.patch(options))),
+  )
 }

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

@@ -0,0 +1,83 @@
+import {expectTypeOf, test} from 'vitest'
+
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {type FetcherSnapshot} from '../store/fetcherStore'
+import {
+  type Application,
+  application,
+  type ApplicationBase,
+  type ApplicationDeployment,
+  type ApplicationInclude,
+  type ApplicationInterface,
+  applications,
+  type ApplicationsResponse,
+  type ApplicationStudioConfig,
+} from './applications'
+
+const instance = {} as SanityInstance
+
+type ChildKeys = 'config' | 'activeDeployment'
+type DeploymentChildKeys = 'interfaces' | 'workspaces' | 'access'
+
+// Whether key `K` of `T` is optional, without an `{}`-based check.
+type KeyModifier<T, K extends keyof T> =
+  Pick<T, K> extends Required<Pick<T, K>> ? 'required' : 'optional'
+
+test('Application — no includes: only the base shape, no config or activeDeployment', () => {
+  expectTypeOf<Application>().toEqualTypeOf<ApplicationBase>()
+  expectTypeOf<Application<never>>().toEqualTypeOf<ApplicationBase>()
+  expectTypeOf<Extract<keyof Application, ChildKeys>>().toEqualTypeOf<never>()
+})
+
+test('Application — config.studio adds a required config.studio', () => {
+  expectTypeOf<
+    Application<'config.studio'>['config']['studio']
+  >().toEqualTypeOf<ApplicationStudioConfig>()
+  // mfManifest not requested → not present under config
+  expectTypeOf<
+    Extract<keyof Application<'config.studio'>['config'], 'mfManifest'>
+  >().toEqualTypeOf<never>()
+  // requesting only config does not pull in the deployment
+  expectTypeOf<
+    Extract<keyof Application<'config.studio'>, 'activeDeployment'>
+  >().toEqualTypeOf<never>()
+})
+
+test('Application — both config tokens merge under a single config', () => {
+  type Config = Application<'config.studio' | 'config.mfManifest'>['config']
+  expectTypeOf<Config['studio']>().toEqualTypeOf<ApplicationStudioConfig>()
+  expectTypeOf<Config['mfManifest']>().toEqualTypeOf<unknown>()
+})
+
+test('Application — activeDeployment token adds the deployment summary, no children', () => {
+  expectTypeOf<
+    Application<'activeDeployment'>['activeDeployment']
+  >().toEqualTypeOf<ApplicationDeployment<'activeDeployment'> | null>()
+  type Deployment = NonNullable<Application<'activeDeployment'>['activeDeployment']>
+  expectTypeOf<Extract<keyof Deployment, DeploymentChildKeys>>().toEqualTypeOf<never>()
+})
+
+test('Application — a child token forces the deployment in and adds only that child', () => {
+  type Deployment = NonNullable<Application<'interfaces'>['activeDeployment']>
+  expectTypeOf<Deployment['interfaces']>().toEqualTypeOf<ApplicationInterface[]>()
+  expectTypeOf<Extract<keyof Deployment, 'workspaces' | 'access'>>().toEqualTypeOf<never>()
+})
+
+test('Application — a wide include array makes config and activeDeployment optional', () => {
+  type Wide = Application<ApplicationInclude>
+  expectTypeOf<KeyModifier<Wide, 'activeDeployment'>>().toEqualTypeOf<'optional'>()
+  expectTypeOf<KeyModifier<Wide, 'config'>>().toEqualTypeOf<'optional'>()
+})
+
+test('applications.resolveState — resolves the wide list envelope', () => {
+  expectTypeOf(
+    applications.resolveState(instance, {organizationId: 'org_1'}),
+  ).resolves.toEqualTypeOf<ApplicationsResponse<ApplicationInclude>>()
+})
+
+test('application.getState — exposes the snapshot envelope', () => {
+  expectTypeOf(application.getState(instance, 'app_1')).toEqualTypeOf<
+    StateSource<FetcherSnapshot<Application<ApplicationInclude>>>
+  >()
+})

package/src/applications/applications.test.ts

@@ -0,0 +1,130 @@
+import {type SanityClient} from '@sanity/client'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {getClientState} from '../client/clientStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {defineMutation} from '../store/fetcherStore'
+import {application, applications, deleteApplication, updateApplication} from './applications'
+
+vi.mock('../client/clientStore')
+
+describe('applications', () => {
+  let instance: SanityInstance
+  const request = vi.fn()
+
+  beforeEach(() => {
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    request.mockReset()
+    vi.mocked(getClientState).mockReturnValue({
+      observable: of({observable: {request}} as unknown as SanityClient),
+    } as StateSource<SanityClient>)
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
+  it('lists applications for an organization, serialising include as a sorted CSV', async () => {
+    const response = {nextCursor: null, data: [{id: 'app1'}]}
+    request.mockReturnValue(of(response))
+
+    const result = await applications.resolveState(instance, {
+      organizationId: 'org1',
+      include: ['workspaces', 'access'],
+      limit: 'none',
+    })
+
+    expect(result).toEqual(response)
+    expect(getClientState).toHaveBeenCalledWith(instance, {
+      apiVersion: 'vX',
+      scope: 'global',
+    })
+    expect(request).toHaveBeenCalledWith({
+      uri: '/applications',
+      query: {organizationId: 'org1', include: 'access,workspaces', limit: 'none'},
+      tag: 'applications.list',
+    })
+  })
+
+  it('fetches a single application by id', async () => {
+    const app = {id: 'app1', title: 'One'}
+    request.mockReturnValue(of(app))
+
+    const result = await application.resolveState(instance, 'app1')
+
+    expect(result).toEqual(app)
+    expect(request).toHaveBeenCalledWith({
+      uri: '/applications/app1',
+      query: {},
+      tag: 'applications.get',
+    })
+  })
+
+  it('refetches the list when a mutation invalidates the LIST tag', async () => {
+    let n = 0
+    request.mockImplementation(() => of({nextCursor: null, data: [{id: `app-${++n}`}]}))
+
+    const source = applications.getState(instance, {organizationId: 'org1'})
+    const unsubscribe = source.subscribe()
+    await vi.waitFor(() => expect(source.getCurrent().status).toBe('success'))
+    expect(request).toHaveBeenCalledTimes(1)
+
+    const install = defineMutation<undefined, {ok: boolean}>({
+      name: 'test-install-application',
+      mutationFn: () => () => of({ok: true}),
+      invalidates: [{type: 'application', id: 'LIST'}],
+    })
+
+    const {invalidated} = await install(instance, undefined)
+    await invalidated
+
+    expect(request).toHaveBeenCalledTimes(2)
+    expect(source.getCurrent().data).toEqual({nextCursor: null, data: [{id: 'app-2'}]})
+    unsubscribe()
+  })
+
+  it('updates an application via PATCH and refetches the invalidated list', async () => {
+    request.mockImplementation((opts) => {
+      const {method} = opts as {method?: string}
+      return method === 'PATCH'
+        ? of({id: 'app1', title: 'New'})
+        : of({nextCursor: null, data: [{id: 'app1'}]})
+    })
+
+    const source = applications.getState(instance, {organizationId: 'org1'})
+    const unsubscribe = source.subscribe()
+    await vi.waitFor(() => expect(source.getCurrent().status).toBe('success'))
+
+    const {data, invalidated} = await updateApplication(instance, {
+      applicationId: 'app1',
+      title: 'New',
+    })
+    await invalidated
+
+    expect(data).toEqual({id: 'app1', title: 'New'})
+    expect(request).toHaveBeenCalledWith({
+      uri: '/applications/app1',
+      method: 'PATCH',
+      body: {title: 'New'},
+      tag: 'applications.update',
+    })
+    // initial list GET + PATCH + list refetch after invalidation
+    expect(request).toHaveBeenCalledTimes(3)
+    unsubscribe()
+  })
+
+  it('deletes an application via DELETE with no body', async () => {
+    request.mockReturnValue(of({deleted: true}))
+
+    const {data} = await deleteApplication(instance, {applicationId: 'app1'})
+
+    expect(data).toEqual({deleted: true})
+    expect(request).toHaveBeenCalledWith({
+      uri: '/applications/app1',
+      method: 'DELETE',
+      tag: 'applications.delete',
+    })
+  })
+})

package/src/applications/applications.ts

@@ -0,0 +1,364 @@
+import {switchMap} from 'rxjs'
+
+import {getClientState} from '../client/clientStore'
+import {defineFetcher, defineMutation} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
+import {type Included, type IncludesAny} from '../utils/includeShape'
+
+// The Applications API is currently only available on vX.
+const API_VERSION = 'vX'
+
+/**
+ * Related data the Applications API can embed in a response. `interfaces`,
+ * `workspaces` and `access` are children of the active deployment and are
+ * embedded under {@link Application.activeDeployment}; `config.studio` and
+ * `config.mfManifest` are embedded under {@link Application.config}.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export type ApplicationInclude =
+  | 'interfaces'
+  | 'workspaces'
+  | 'access'
+  | 'config.studio'
+  | 'config.mfManifest'
+  | 'activeDeployment'
+
+/**
+ * An interface exposed by a deployment, embedded when `interfaces` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationInterface {
+  id: string
+  type: 'app' | 'worker' | 'asset_source' | 'panel'
+  name: string
+  title: string
+  version: string
+  /** Module federation module ID; resolved from the host mf-manifest at runtime */
+  moduleId: string
+  metadata: {group?: string; priority?: number} | null
+}
+
+/**
+ * A studio workspace of a deployment, embedded when `workspaces` is included.
+ * Studio applications only.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationWorkspace {
+  id: string
+  name: string
+  title: string | null
+  subtitle: string | null
+  projectId: string
+  dataset: string
+  schemaDescriptorId: string | null
+  basePath: string | null
+  /** Sanitized SVG icon markup */
+  icon: string | null
+}
+
+/**
+ * A resource an application accesses, embedded when `access` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationAccess {
+  id: string
+  resourceType: 'datasets' | 'canvases' | 'dashboards' | 'media-libraries'
+  resourceId: string
+}
+
+/**
+ * Studio configuration, embedded under `config` when `config.studio` is included.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationStudioConfig {
+  projectId: string
+  /** Release channel (`next`, `stable`, `latest`) or a pinned semver; null if unset */
+  autoUpdatingVersion: string | null
+}
+
+/**
+ * The active deployment as embedded under {@link Application.activeDeployment}.
+ * Its `interfaces`, `workspaces` and `access` children are each present only
+ * when the matching {@link ApplicationInclude} token was requested. `workspaces`
+ * is omitted (not `null`) for non-studio applications even when requested.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export type ApplicationDeployment<Include extends ApplicationInclude = never> = {
+  id: string
+  applicationId: string
+  size: number | null
+  version: string | null
+  isAutoUpdating: boolean | null
+  isActiveDeployment: boolean
+  deployedBy: string | null
+  createdAt: string
+  updatedAt: string
+} & Included<ApplicationInclude, 'interfaces', Include, {interfaces: ApplicationInterface[]}> &
+  Included<ApplicationInclude, 'workspaces', Include, {workspaces?: ApplicationWorkspace[]}> &
+  Included<ApplicationInclude, 'access', Include, {access: ApplicationAccess[]}>
+
+/**
+ * The always-present fields of an org-owned application returned by the
+ * Applications API (`/applications`), before any {@link ApplicationInclude}.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationBase {
+  id: string
+  type: 'studio' | 'coreApp'
+  title: string
+  icon: string | null
+  isSingleton: boolean
+  visibility: 'default' | 'unlisted' | 'disabled'
+  slug: string | null
+  externalUrl: string | null
+  organizationId: string
+  createdAt: string
+  updatedAt: string
+}
+
+// Requesting any of these tokens forces the deployment summary into the response.
+type DeploymentToken = 'activeDeployment' | 'interfaces' | 'workspaces' | 'access'
+
+// `config` is present when either config child was requested; each child is
+// gated on its own token.
+type ApplicationConfigShape<Include extends ApplicationInclude> = Included<
+  ApplicationInclude,
+  'config.studio',
+  Include,
+  {config: {studio: ApplicationStudioConfig}}
+> &
+  Included<ApplicationInclude, 'config.mfManifest', Include, {config: {mfManifest: unknown}}>
+
+// `activeDeployment` is present when any deployment-related token was requested;
+// a wide include array makes it optional.
+type ApplicationDeploymentShape<Include extends ApplicationInclude> = [ApplicationInclude] extends [
+  Include,
+]
+  ? {activeDeployment?: ApplicationDeployment<Include> | null}
+  : IncludesAny<Include, DeploymentToken> extends true
+    ? {activeDeployment: ApplicationDeployment<Include> | null}
+    : unknown
+
+/**
+ * An org-owned application as returned by the Applications API
+ * (`/applications`). `config` and `activeDeployment` (with its
+ * `interfaces`/`workspaces`/`access` children) are present only when the
+ * corresponding {@link ApplicationInclude} tokens were requested.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export type Application<Include extends ApplicationInclude = never> = ApplicationBase &
+  ApplicationConfigShape<Include> &
+  ApplicationDeploymentShape<Include>
+
+/**
+ * Options for listing an organization's applications.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationsOptions<Include extends ApplicationInclude = ApplicationInclude> {
+  organizationId: string
+  /** Filter by application type */
+  type?: string
+  include?: Include[]
+  /** Page size (1-100, default 50), or `'none'` to disable pagination */
+  limit?: number | 'none'
+  /** Cursor from a previous response's `nextCursor` */
+  cursor?: string
+}
+
+/**
+ * The cursor-paginated envelope returned by `GET /applications`.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface ApplicationsResponse<Include extends ApplicationInclude = never> {
+  nextCursor: string | null
+  data: Application<Include>[]
+}
+
+/** The API takes `include` as a comma-separated list; sorted so key and query agree */
+function serializeInclude(include: ApplicationInclude[] | undefined): string | undefined {
+  return include?.length ? [...include].sort().join(',') : undefined
+}
+
+/**
+ * Fetcher for an organization's applications (`GET /applications`), on the
+ * shared fetcher cache.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const applications = defineFetcher<
+  [options: ApplicationsOptions],
+  ApplicationsResponse<ApplicationInclude>
+>({
+  name: 'applications',
+  getKey: (_instance, options) =>
+    [
+      options.organizationId,
+      options.type ?? '',
+      serializeInclude(options.include) ?? '',
+      options.limit ?? '',
+      options.cursor ?? '',
+    ].join(':'),
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<ApplicationsResponse<ApplicationInclude>>({
+          uri: '/applications',
+          query: buildQuery({
+            organizationId: options.organizationId,
+            type: options.type,
+            include: serializeInclude(options.include),
+            limit: options.limit,
+            cursor: options.cursor,
+          }),
+          tag: 'applications.list',
+        }),
+      ),
+    ),
+  tags: (data) => [
+    {type: 'application', id: 'LIST'},
+    ...data.data.map((app) => ({type: 'application', id: app.id})),
+  ],
+})
+
+/**
+ * Fetcher for a single application (`GET /applications/:id`), on the shared
+ * fetcher cache. No pre-seeding from {@link applications}: its list keys
+ * include the organization, which this fetcher's params can't reconstruct.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const application = defineFetcher<
+  [applicationId: string, options?: {include?: ApplicationInclude[]}],
+  Application<ApplicationInclude>
+>({
+  name: 'application',
+  getKey: (_instance, applicationId, options) =>
+    `${applicationId}:${serializeInclude(options?.include) ?? ''}`,
+  fetch: (instance) => (applicationId, options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<Application<ApplicationInclude>>({
+          uri: `/applications/${applicationId}`,
+          query: buildQuery({include: serializeInclude(options?.include)}),
+          tag: 'applications.get',
+        }),
+      ),
+    ),
+  tags: (data) => [{type: 'application', id: data.id}],
+})
+
+/**
+ * Confirmation returned by the API's soft-delete endpoints.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export interface DeletedResult {
+  deleted: boolean
+}
+
+/**
+ * Dashboard visibility for an application. The same set of values backs a user
+ * application's `dashboardStatus`.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export type ApplicationVisibility = ApplicationBase['visibility']
+
+/**
+ * Mutable properties of an application (`PATCH /applications/:id`) — the
+ * writable subset of {@link ApplicationBase}, each optional, keyed by id.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export type UpdateApplicationInput = {applicationId: string} & Partial<
+  Pick<ApplicationBase, 'title' | 'icon' | 'visibility'>
+>
+
+/**
+ * Mutation to update an application (`PATCH /applications/:id`). Invalidates the
+ * updated application and the list so active entries reconverge on server truth.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const updateApplication = defineMutation<UpdateApplicationInput, Application>({
+  name: 'updateApplication',
+  mutationFn:
+    (instance) =>
+    ({applicationId, ...body}) =>
+      getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+        switchMap((client) =>
+          client.observable.request<Application>({
+            uri: `/applications/${applicationId}`,
+            method: 'PATCH',
+            body,
+            tag: 'applications.update',
+          }),
+        ),
+      ),
+  invalidates: (_result, {applicationId}) => [
+    {type: 'application', id: 'LIST'},
+    {type: 'application', id: applicationId},
+  ],
+})
+
+/**
+ * Input for {@link deleteApplication}.
+ *
+ * @internal
+ */
+export interface DeleteApplicationInput {
+  applicationId: string
+}
+
+/**
+ * Mutation to soft-delete an application (`DELETE /applications/:id`).
+ * Invalidates the deleted application and the list.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const deleteApplication = defineMutation<DeleteApplicationInput, DeletedResult>({
+  name: 'deleteApplication',
+  mutationFn:
+    (instance) =>
+    ({applicationId}) =>
+      getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+        switchMap((client) =>
+          client.observable.request<DeletedResult>({
+            uri: `/applications/${applicationId}`,
+            method: 'DELETE',
+            tag: 'applications.delete',
+          }),
+        ),
+      ),
+  invalidates: (_result, {applicationId}) => [
+    {type: 'application', id: 'LIST'},
+    {type: 'application', id: applicationId},
+  ],
+})