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

package/src/agent/agentActions.test.ts

@@ -11,16 +11,13 @@ import {
 } from './agentActions'
 
 let mockClient: any
-const mockGetClientState = vi.fn()
 
 vi.mock('../client/clientStore', () => {
   return {
-    getClientState: (...args: unknown[]) => mockGetClientState(...args),
+    getClientState: () => ({observable: of(mockClient)}),
   }
 })
 
-const testResource = {projectId: 'p', dataset: 'd'}
-
 describe('agent actions', () => {
   beforeEach(() => {
     mockClient = {
@@ -40,86 +37,45 @@ describe('agent actions', () => {
         },
       },
     }
-    mockGetClientState.mockReturnValue({observable: of(mockClient)})
   })
 
-  it('agentGenerate passes resource to getClientState and strips it from agent options', async () => {
+  it('agentGenerate returns observable from client', async () => {
     mockClient.observable.agent.action.generate.mockReturnValue(of('gen'))
-    const instance = {config: {}} as any
-    const value = await firstValueFrom(
-      agentGenerate(instance, {foo: 'bar', resource: testResource} as any),
-    )
+    const instance = {config: {projectId: 'p', dataset: 'd'}} as any
+    const value = await firstValueFrom(agentGenerate(instance, {foo: 'bar'} as any))
     expect(value).toBe('gen')
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: testResource,
-    })
     expect(mockClient.observable.agent.action.generate).toHaveBeenCalledWith({foo: 'bar'})
   })
 
-  it('agentTransform passes resource to getClientState and strips it from agent options', async () => {
+  it('agentTransform returns observable from client', async () => {
     mockClient.observable.agent.action.transform.mockReturnValue(of('xform'))
-    const instance = {config: {}} as any
-    const value = await firstValueFrom(
-      agentTransform(instance, {a: 1, resource: testResource} as any),
-    )
+    const instance = {config: {projectId: 'p', dataset: 'd'}} as any
+    const value = await firstValueFrom(agentTransform(instance, {a: 1} as any))
     expect(value).toBe('xform')
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: testResource,
-    })
     expect(mockClient.observable.agent.action.transform).toHaveBeenCalledWith({a: 1})
   })
 
-  it('agentTranslate passes resource to getClientState and strips it from agent options', async () => {
+  it('agentTranslate returns observable from client', async () => {
     mockClient.observable.agent.action.translate.mockReturnValue(of('xlate'))
-    const instance = {config: {}} as any
-    const value = await firstValueFrom(
-      agentTranslate(instance, {b: 2, resource: testResource} as any),
-    )
+    const instance = {config: {projectId: 'p', dataset: 'd'}} as any
+    const value = await firstValueFrom(agentTranslate(instance, {b: 2} as any))
     expect(value).toBe('xlate')
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: testResource,
-    })
     expect(mockClient.observable.agent.action.translate).toHaveBeenCalledWith({b: 2})
   })
 
-  it('agentPrompt passes resource to getClientState and strips it from agent options', async () => {
+  it('agentPrompt wraps promise into observable', async () => {
     mockClient.agent.action.prompt.mockResolvedValue('prompted')
-    const instance = {config: {}} as any
-    const value = await firstValueFrom(
-      agentPrompt(instance, {p: true, resource: testResource} as any),
-    )
+    const instance = {config: {projectId: 'p', dataset: 'd'}} as any
+    const value = await firstValueFrom(agentPrompt(instance, {p: true} as any))
     expect(value).toBe('prompted')
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: testResource,
-    })
     expect(mockClient.agent.action.prompt).toHaveBeenCalledWith({p: true})
   })
 
-  it('agentPatch passes resource to getClientState and strips it from agent options', async () => {
+  it('agentPatch wraps promise into observable', async () => {
     mockClient.agent.action.patch.mockResolvedValue('patched')
-    const instance = {config: {}} as any
-    const value = await firstValueFrom(
-      agentPatch(instance, {q: false, resource: testResource} as any),
-    )
+    const instance = {config: {projectId: 'p', dataset: 'd'}} as any
+    const value = await firstValueFrom(agentPatch(instance, {q: false} as any))
     expect(value).toBe('patched')
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: testResource,
-    })
     expect(mockClient.agent.action.patch).toHaveBeenCalledWith({q: false})
   })
-
-  it('works without an explicit resource (falls back via getClientState)', async () => {
-    mockClient.observable.agent.action.generate.mockReturnValue(of('gen'))
-    const instance = {config: {}} as any
-    await firstValueFrom(agentGenerate(instance, {foo: 'bar'} as any))
-    expect(mockGetClientState).toHaveBeenCalledWith(instance, {
-      apiVersion: 'vX',
-      resource: undefined,
-    })
-  })
 })

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,88 @@
+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('ApplicationBase — carries name and reference as strings', () => {
+  expectTypeOf<ApplicationBase['name']>().toEqualTypeOf<string>()
+  expectTypeOf<ApplicationBase['reference']>().toEqualTypeOf<string>()
+})
+
+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',
+    })
+  })
+})