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

package/src/applications/userApplications.test.ts

@@ -0,0 +1,126 @@
+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 {
+  createUserApplication,
+  deleteUserApplication,
+  updateUserApplication,
+  userApplication,
+  userApplications,
+} from './userApplications'
+
+vi.mock('../client/clientStore')
+
+describe('userApplications', () => {
+  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 user applications for an organization on the global client', async () => {
+    const apps = [{id: 'ua1'}, {id: 'ua2'}]
+    request.mockReturnValue(of(apps))
+
+    const result = await userApplications.resolveState(instance, {organizationId: 'org1'})
+
+    expect(result).toEqual(apps)
+    expect(getClientState).toHaveBeenCalledWith(instance, {
+      apiVersion: 'v2024-08-01',
+      scope: 'global',
+    })
+    expect(request).toHaveBeenCalledWith({
+      uri: '/user-applications',
+      query: {organizationId: 'org1'},
+      tag: 'user-applications.list',
+    })
+  })
+
+  it('fetches a single user application by id', async () => {
+    const app = {id: 'ua1', appHost: 'my-studio'}
+    request.mockReturnValue(of(app))
+
+    const result = await userApplication.resolveState(instance, 'ua1')
+
+    expect(result).toEqual(app)
+    expect(request).toHaveBeenCalledWith({
+      uri: '/user-applications/ua1',
+      tag: 'user-applications.get',
+    })
+  })
+
+  it('creates a user application, sending query params and body, and refetches the list', async () => {
+    request.mockImplementation((opts) => {
+      const {method} = opts as {method?: string}
+      return method === 'POST' ? of({id: 'ua-new', title: 'New'}) : of([{id: 'ua-new'}])
+    })
+
+    const source = userApplications.getState(instance, {organizationId: 'org1'})
+    const unsubscribe = source.subscribe()
+    await vi.waitFor(() => expect(source.getCurrent().status).toBe('success'))
+
+    const {data, invalidated} = await createUserApplication(instance, {
+      organizationId: 'org1',
+      appType: 'studio',
+      urlType: 'internal',
+      appHost: 'my-studio',
+      title: 'New',
+    })
+    await invalidated
+
+    expect(data).toEqual({id: 'ua-new', title: 'New'})
+    expect(request).toHaveBeenCalledWith({
+      uri: '/user-applications',
+      method: 'POST',
+      query: {organizationId: 'org1', appType: 'studio'},
+      body: {urlType: 'internal', appHost: 'my-studio', title: 'New'},
+      tag: 'user-applications.create',
+    })
+    // initial list GET + POST + list refetch after invalidation
+    expect(request).toHaveBeenCalledTimes(3)
+    unsubscribe()
+  })
+
+  it('updates a user application via PATCH', async () => {
+    request.mockReturnValue(of({id: 'ua1', title: 'Renamed'}))
+
+    const {data} = await updateUserApplication(instance, {
+      userApplicationId: 'ua1',
+      title: 'Renamed',
+    })
+
+    expect(data).toEqual({id: 'ua1', title: 'Renamed'})
+    expect(request).toHaveBeenCalledWith({
+      uri: '/user-applications/ua1',
+      method: 'PATCH',
+      body: {title: 'Renamed'},
+      tag: 'user-applications.update',
+    })
+  })
+
+  it('deletes a user application via DELETE with no body', async () => {
+    request.mockReturnValue(of({deleted: true}))
+
+    const {data} = await deleteUserApplication(instance, {userApplicationId: 'ua1'})
+
+    expect(data).toEqual({deleted: true})
+    expect(request).toHaveBeenCalledWith({
+      uri: '/user-applications/ua1',
+      method: 'DELETE',
+      tag: 'user-applications.delete',
+    })
+  })
+})

package/src/applications/userApplications.ts

@@ -0,0 +1,261 @@
+import {switchMap} from 'rxjs'
+
+import {getClientState} from '../client/clientStore'
+import {defineFetcher, defineMutation} from '../store/fetcherStore'
+import {buildQuery} from '../utils/buildQuery'
+import {type ApplicationVisibility, type DeletedResult} from './applications'
+
+// The version the CLI pins for this API family; verify against the deployed
+// API before promoting these stores past @internal.
+const API_VERSION = 'v2024-08-01'
+
+/**
+ * A deployment of a user application, embedded when `activeDeployment` is
+ * included on the User Applications API. Distinct from the org Applications
+ * API's {@link ApplicationDeployment} summary.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface UserApplicationDeployment {
+  id: string
+  version: string | null
+  isActiveDeployment: boolean
+  userApplicationId: string
+  isAutoUpdating: boolean | null
+  size: number | null
+  deployedAt: string
+  deployedBy: string | null
+  createdAt: string
+  updatedAt: string
+  manifest: unknown
+}
+
+/**
+ * A user application (deployed studio or custom app) as returned by
+ * `/user-applications`.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface UserApplication {
+  id: string
+  projectId: string | null
+  organizationId: string | null
+  title: string | null
+  type: string
+  urlType: string
+  appHost: string
+  dashboardStatus: string
+  createdAt: string
+  updatedAt: string
+  autoUpdatingVersion: string | null
+  activeDeployment: UserApplicationDeployment | null
+  manifestData: unknown
+  config: Record<string, unknown> | null
+  manifest: unknown
+}
+
+/**
+ * Options for listing an organization's user applications.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @public
+ */
+export interface UserApplicationsOptions {
+  organizationId: string
+}
+
+/**
+ * Fetcher for an organization's user applications (`GET /user-applications`),
+ * on the shared fetcher cache.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const userApplications = defineFetcher<
+  [options: UserApplicationsOptions],
+  UserApplication[]
+>({
+  name: 'userApplications',
+  getKey: (_instance, options) => options.organizationId,
+  fetch: (instance) => (options) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<UserApplication[]>({
+          uri: '/user-applications',
+          query: buildQuery({organizationId: options.organizationId}),
+          tag: 'user-applications.list',
+        }),
+      ),
+    ),
+  tags: (data) => [
+    {type: 'user-application', id: 'LIST'},
+    ...data.map((app) => ({type: 'user-application', id: app.id})),
+  ],
+})
+
+/**
+ * Fetcher for a single user application (`GET /user-applications/:id`), on the
+ * shared fetcher cache. No pre-seeding from {@link userApplications}: 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 userApplication = defineFetcher<[userApplicationId: string], UserApplication>({
+  name: 'userApplication',
+  getKey: (_instance, userApplicationId) => userApplicationId,
+  fetch: (instance) => (userApplicationId) =>
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+      switchMap((client) =>
+        client.observable.request<UserApplication>({
+          uri: `/user-applications/${userApplicationId}`,
+          tag: 'user-applications.get',
+        }),
+      ),
+    ),
+  tags: (data) => [{type: 'user-application', id: data.id}],
+})
+
+/**
+ * Fields you can set when creating or updating a user application.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export interface UserApplicationWriteFields {
+  /** Human-friendly display name; `null` clears it */
+  title?: string | null
+  /** `internal` for Sanity-hosted studios, `external` for externally hosted */
+  urlType?: 'internal' | 'external'
+  /** Studio subdomain (internal) or full `https` URL (external) */
+  appHost?: string
+  /** Internal apps only: make this the default app for the deployment */
+  isDefaultForDeployment?: boolean
+  /** Dashboard visibility */
+  dashboardStatus?: ApplicationVisibility
+  /** Auto-update channel or a pinned semver */
+  autoUpdatingVersion?: string | null
+}
+
+/**
+ * Input for {@link createUserApplication}: the writable fields, with `urlType`
+ * and `appHost` required. `organizationId` and `appType` are sent as query
+ * parameters; the rest form the request body.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export interface CreateUserApplicationInput extends UserApplicationWriteFields {
+  /** Query param: owning organization */
+  organizationId?: string
+  /** Query param: `studio` or `coreApp` */
+  appType?: 'studio' | 'coreApp'
+  urlType: 'internal' | 'external'
+  appHost: string
+  /** Create does not accept a `null` title */
+  title?: string
+}
+
+/**
+ * Mutation to create a user application (`POST /user-applications`). Invalidates
+ * the list so it reconverges to include the new entry.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const createUserApplication = defineMutation<CreateUserApplicationInput, UserApplication>({
+  name: 'createUserApplication',
+  mutationFn:
+    (instance) =>
+    ({organizationId, appType, ...body}) =>
+      getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+        switchMap((client) =>
+          client.observable.request<UserApplication>({
+            uri: '/user-applications',
+            method: 'POST',
+            query: buildQuery({organizationId, appType}),
+            body,
+            tag: 'user-applications.create',
+          }),
+        ),
+      ),
+  invalidates: [{type: 'user-application', id: 'LIST'}],
+})
+
+/**
+ * Input for {@link updateUserApplication}: the writable fields (all optional),
+ * keyed by id.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export interface UpdateUserApplicationInput extends UserApplicationWriteFields {
+  userApplicationId: string
+}
+
+/**
+ * Mutation to update a user application (`PATCH /user-applications/:id`).
+ * Invalidates the updated entry and the list.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const updateUserApplication = defineMutation<UpdateUserApplicationInput, UserApplication>({
+  name: 'updateUserApplication',
+  mutationFn:
+    (instance) =>
+    ({userApplicationId, ...body}) =>
+      getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+        switchMap((client) =>
+          client.observable.request<UserApplication>({
+            uri: `/user-applications/${userApplicationId}`,
+            method: 'PATCH',
+            body,
+            tag: 'user-applications.update',
+          }),
+        ),
+      ),
+  invalidates: (_result, {userApplicationId}) => [
+    {type: 'user-application', id: 'LIST'},
+    {type: 'user-application', id: userApplicationId},
+  ],
+})
+
+/**
+ * Input for {@link deleteUserApplication}.
+ *
+ * @internal
+ */
+export interface DeleteUserApplicationInput {
+  userApplicationId: string
+}
+
+/**
+ * Mutation to delete a user application (`DELETE /user-applications/:id`).
+ * Invalidates the deleted entry and the list.
+ *
+ * @see https://www.sanity.io/docs/http-reference/applications-api
+ * @internal
+ */
+export const deleteUserApplication = defineMutation<DeleteUserApplicationInput, DeletedResult>({
+  name: 'deleteUserApplication',
+  mutationFn:
+    (instance) =>
+    ({userApplicationId}) =>
+      getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable.pipe(
+        switchMap((client) =>
+          client.observable.request<DeletedResult>({
+            uri: `/user-applications/${userApplicationId}`,
+            method: 'DELETE',
+            tag: 'user-applications.delete',
+          }),
+        ),
+      ),
+  invalidates: (_result, {userApplicationId}) => [
+    {type: 'user-application', id: 'LIST'},
+    {type: 'user-application', id: userApplicationId},
+  ],
+})

package/src/auth/authLogger.ts

@@ -0,0 +1,30 @@
+import {type SanityInstance} from '../store/createSanityInstance'
+import {createLogger, type Logger} from '../utils/logger'
+
+const loggers = new WeakMap<SanityInstance, Logger>()
+
+/**
+ * Returns the auth logger for a Sanity instance, creating it on first use.
+ *
+ * The logger is cached per instance so repeated action calls (logout,
+ * setAuthToken, handleAuthCallback) reuse the same logger instead of
+ * rebuilding it. The instance details are nested under `instanceContext`,
+ * which is what the logger's formatter reads to render the
+ * `[project:x] [dataset:y] [instance:z]` prefix.
+ *
+ * @internal
+ */
+export function getAuthLogger(instance: SanityInstance): Logger {
+  let logger = loggers.get(instance)
+  if (!logger) {
+    logger = createLogger('auth', {
+      instanceContext: {
+        instanceId: instance.instanceId,
+        projectId: instance.config.projectId,
+        dataset: instance.config.dataset,
+      },
+    })
+    loggers.set(instance, logger)
+  }
+  return logger
+}

package/src/auth/authMode.test.ts

@@ -9,6 +9,11 @@ describe('resolveAuthMode', () => {
     expect(resolveAuthMode(config, 'https://example.com')).toBe('studio')
   })
 
+  it('returns "studio" when deprecated studioMode.enabled is true', () => {
+    const config: SanityConfig = {studioMode: {enabled: true}}
+    expect(resolveAuthMode(config, 'https://example.com')).toBe('studio')
+  })
+
   it('returns "dashboard" when _context URL param has a non-empty JSON object', () => {
     const context = encodeURIComponent(JSON.stringify({orgId: '123'}))
     const href = `https://example.com?_context=${context}`
@@ -18,6 +23,14 @@ describe('resolveAuthMode', () => {
   it('returns "standalone" by default', () => {
     expect(resolveAuthMode({}, 'https://example.com')).toBe('standalone')
   })
+
+  it('prefers studio config over studioMode', () => {
+    const config: SanityConfig = {
+      studio: {},
+      studioMode: {enabled: true},
+    }
+    expect(resolveAuthMode(config, 'https://example.com')).toBe('studio')
+  })
 })
 
 describe('isStudioConfig', () => {
@@ -25,7 +38,19 @@ describe('isStudioConfig', () => {
     expect(isStudioConfig({studio: {}})).toBe(true)
   })
 
+  it('returns true when deprecated studioMode.enabled is true', () => {
+    expect(isStudioConfig({studioMode: {enabled: true}})).toBe(true)
+  })
+
+  it('returns false when studioMode.enabled is false', () => {
+    expect(isStudioConfig({studioMode: {enabled: false}})).toBe(false)
+  })
+
   it('returns false for empty config', () => {
     expect(isStudioConfig({})).toBe(false)
   })
+
+  it('returns true when both studio and studioMode are present', () => {
+    expect(isStudioConfig({studio: {}, studioMode: {enabled: true}})).toBe(true)
+  })
 })

package/src/auth/authMode.ts

@@ -20,8 +20,9 @@ type AuthMode = 'studio' | 'dashboard' | 'standalone'
  *
  * Priority:
  * 1. `studio` config provided → `'studio'`
- * 2. Dashboard context detected (`_context` URL param with content) → `'dashboard'`
- * 3. Otherwise → `'standalone'`
+ * 2. `studioMode.enabled` in config (deprecated) → `'studio'`
+ * 3. Dashboard context detected (`_context` URL param with content) → `'dashboard'`
+ * 4. Otherwise → `'standalone'`
  *
  * @internal
  */
@@ -33,11 +34,13 @@ export function resolveAuthMode(config: SanityConfig, locationHref: string): Aut
 
 /**
  * Returns `true` when the config indicates the SDK is running inside a Studio.
+ * Checks the new `studio` field first, then falls back to the deprecated
+ * `studioMode.enabled` for backwards compatibility.
  *
  * @internal
  */
 export function isStudioConfig(config: SanityConfig): boolean {
-  return !!config.studio
+  return !!config.studio || !!config.studioMode?.enabled
 }
 
 /**