@sanity/sdk-react 3.1.0 → 3.3.0-rc.0

package/src/hooks/auth/useOAuthTokens.test.tsx

@@ -0,0 +1,240 @@
+import {
+  getOAuthTokensState,
+  type OAuthTokens,
+  refreshOAuthTokens,
+  revokeOAuthTokens,
+  type StateSource,
+} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
+import {throwError} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useOAuthTokens} from './useOAuthTokens'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    getOAuthTokensState: vi.fn(),
+    refreshOAuthTokens: vi.fn(),
+    revokeOAuthTokens: vi.fn(),
+  }
+})
+
+/**
+ * A controllable stand-in for core's token state source. `set` mimics core
+ * updating the store (refresh/revoke or a cross-tab `storage` event) and
+ * notifies subscribers so the hook re-renders.
+ */
+function createFakeTokenSource(initial: OAuthTokens | null) {
+  let current = initial
+  const listeners = new Set<() => void>()
+  const source: StateSource<OAuthTokens | null> & {set: (next: OAuthTokens | null) => void} = {
+    subscribe: (onStoreChanged?: () => void) => {
+      if (onStoreChanged) listeners.add(onStoreChanged)
+      return () => {
+        if (onStoreChanged) listeners.delete(onStoreChanged)
+      }
+    },
+    getCurrent: () => current,
+    observable: throwError(() => new Error('unexpected usage of observable')),
+    set: (next) => {
+      current = next
+      for (const listener of listeners) listener()
+    },
+  }
+  return source
+}
+
+const makeTokens = (overrides: Partial<OAuthTokens> = {}): OAuthTokens => ({
+  accessToken: 'access-token',
+  tokenType: 'bearer',
+  expiresIn: 3600,
+  expiresAt: new Date(Date.now() + 3600_000),
+  refreshToken: 'refresh-token',
+  ...overrides,
+})
+
+const wrapper = ({children}: {children: React.ReactNode}) => (
+  <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+    {children}
+  </ResourceProvider>
+)
+
+describe('useOAuthTokens', () => {
+  const mockGetState = vi.mocked(getOAuthTokensState)
+  const mockRefresh = vi.mocked(refreshOAuthTokens)
+  const mockRevoke = vi.mocked(revokeOAuthTokens)
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('returns the stored tokens with isExpired=false when expiresAt is in the future', () => {
+    const tokens = makeTokens()
+    mockGetState.mockReturnValue(createFakeTokenSource(tokens))
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    expect(result.current.tokens).toEqual(tokens)
+    expect(result.current.isExpired()).toBe(false)
+  })
+
+  it('derives isExpired=true when expiresAt is in the past', () => {
+    mockGetState.mockReturnValue(
+      createFakeTokenSource(makeTokens({expiresAt: new Date(Date.now() - 1000)})),
+    )
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    expect(result.current.isExpired()).toBe(true)
+  })
+
+  it('treats expiresAt exactly equal to now as expired (<= boundary)', () => {
+    vi.useFakeTimers()
+    const now = new Date('2030-01-01T00:00:00.000Z')
+    vi.setSystemTime(now)
+    mockGetState.mockReturnValue(createFakeTokenSource(makeTokens({expiresAt: new Date(now)})))
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    expect(result.current.isExpired()).toBe(true)
+  })
+
+  it('re-evaluates isExpired against the clock at call time, with no re-render or token change', () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2030-01-01T00:00:00.000Z'))
+    const expiresAt = new Date(Date.now() + 10_000)
+    mockGetState.mockReturnValue(createFakeTokenSource(makeTokens({expiresAt})))
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+    const {isExpired} = result.current
+    expect(isExpired()).toBe(false)
+
+    // Advance past expiry. The same function reference must now report expired,
+    // proving the read happens at call time, not render time.
+    vi.setSystemTime(new Date(expiresAt.getTime() + 1000))
+    expect(isExpired()).toBe(true)
+  })
+
+  it('returns tokens=null and isExpired=false when there are no tokens', () => {
+    mockGetState.mockReturnValue(createFakeTokenSource(null))
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    expect(result.current.tokens).toBeNull()
+    expect(result.current.isExpired()).toBe(false)
+  })
+
+  it('calls core refreshOAuthTokens and re-renders with the new tokens', async () => {
+    const source = createFakeTokenSource(makeTokens())
+    mockGetState.mockReturnValue(source)
+    const refreshed = makeTokens({accessToken: 'refreshed-token'})
+    mockRefresh.mockImplementation(() => {
+      source.set(refreshed)
+      return Promise.resolve(refreshed)
+    })
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    let returned: OAuthTokens | null = null
+    await act(async () => {
+      returned = await result.current.refresh()
+    })
+
+    expect(mockRefresh).toHaveBeenCalledTimes(1)
+    expect(returned).toEqual(refreshed)
+    expect(result.current.tokens).toEqual(refreshed)
+  })
+
+  it('resolves null from refresh when core has no refresh token, and tokens become null', async () => {
+    const existing = makeTokens({refreshToken: undefined})
+    const source = createFakeTokenSource(existing)
+    mockGetState.mockReturnValue(source)
+    // Core clears stored tokens and logs out on the no-refresh-token path.
+    mockRefresh.mockImplementation(() => {
+      source.set(null)
+      return Promise.resolve(null)
+    })
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    let returned: OAuthTokens | null = existing
+    await act(async () => {
+      returned = await result.current.refresh()
+    })
+
+    expect(returned).toBeNull()
+    expect(result.current.tokens).toBeNull()
+  })
+
+  it('propagates a rejected refresh and leaves tokens unchanged', async () => {
+    const existing = makeTokens()
+    mockGetState.mockReturnValue(createFakeTokenSource(existing))
+    mockRefresh.mockRejectedValue(new Error('network'))
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    await act(async () => {
+      await expect(result.current.refresh()).rejects.toThrow('network')
+    })
+
+    expect(result.current.tokens).toEqual(existing)
+  })
+
+  it('propagates an unrecoverable refresh rejection after core has cleared tokens', async () => {
+    const source = createFakeTokenSource(makeTokens())
+    mockGetState.mockReturnValue(source)
+    // Core clears stored tokens and logs out before rethrowing a 4xx.
+    mockRefresh.mockImplementation(() => {
+      source.set(null)
+      return Promise.reject(new Error('invalid_grant'))
+    })
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    await act(async () => {
+      await expect(result.current.refresh()).rejects.toThrow('invalid_grant')
+    })
+
+    expect(result.current.tokens).toBeNull()
+  })
+
+  it('calls core revokeOAuthTokens and re-renders with tokens=null', async () => {
+    const source = createFakeTokenSource(makeTokens())
+    mockGetState.mockReturnValue(source)
+    mockRevoke.mockImplementation(() => {
+      source.set(null)
+      return Promise.resolve()
+    })
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+
+    await act(async () => {
+      await result.current.revoke()
+    })
+
+    expect(mockRevoke).toHaveBeenCalledTimes(1)
+    expect(result.current.tokens).toBeNull()
+  })
+
+  it('re-renders when tokens change externally (e.g. another tab)', () => {
+    const source = createFakeTokenSource(null)
+    mockGetState.mockReturnValue(source)
+
+    const {result} = renderHook(() => useOAuthTokens(), {wrapper})
+    expect(result.current.tokens).toBeNull()
+
+    const otherTabTokens = makeTokens({accessToken: 'other-tab-token'})
+    act(() => {
+      source.set(otherTabTokens)
+    })
+
+    expect(result.current.tokens).toEqual(otherTabTokens)
+  })
+})

package/src/hooks/auth/useOAuthTokens.tsx

@@ -0,0 +1,95 @@
+import {
+  getOAuthTokensState,
+  type OAuthTokens,
+  refreshOAuthTokens,
+  revokeOAuthTokens,
+} from '@sanity/sdk'
+
+import {createCallbackHook} from '../helpers/createCallbackHook'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+/**
+ * The current OAuth token state, plus actions to refresh and revoke it.
+ *
+ * @public
+ */
+export interface UseOAuthTokensResult {
+  /** The stored OAuth tokens, or `null` when not logged in via OAuth */
+  tokens: OAuthTokens | null
+  /**
+   * Returns whether the access token has expired, comparing `expiresAt` against
+   * the current time at the moment it is called. Reading the clock does not
+   * trigger a re-render, so call this in an event handler or effect rather than
+   * during render. Returns `false` when there are no tokens.
+   */
+  isExpired: () => boolean
+  /**
+   * Refresh via the OAuth `refresh_token` grant. When there is no refresh token,
+   * core clears the stored tokens, logs the user out, and this resolves `null`.
+   * Rejects on transient failures (network, 5xx, 408, 429), leaving tokens
+   * unchanged so the call can be retried. Also rejects when the server rejects
+   * the refresh token itself (other 4xx); core clears the tokens and logs out
+   * first, so check `tokens` before retrying.
+   */
+  refresh: () => Promise<OAuthTokens | null>
+  /** Revoke the tokens at the OAuth server, clear them locally, and log out. */
+  revoke: () => Promise<void>
+}
+
+const useOAuthTokensState = createStateSourceHook(getOAuthTokensState)
+const useRefreshOAuthTokens = createCallbackHook(refreshOAuthTokens)
+const useRevokeOAuthTokens = createCallbackHook(revokeOAuthTokens)
+
+function isOAuthTokenExpired(tokens: OAuthTokens | null): boolean {
+  return tokens ? tokens.expiresAt.getTime() <= Date.now() : false
+}
+
+/**
+ * A React hook that exposes the stored OAuth token state along with `refresh`
+ * and `revoke` actions.
+ *
+ * @remarks
+ * The token view is a synchronous read over core's token state source, so the
+ * hook re-renders whenever tokens change — including changes made in another
+ * tab, which core propagates via `storage` events.
+ *
+ * @returns The current {@link UseOAuthTokensResult}
+ *
+ * @example
+ * ```tsx
+ * function TokenStatus() {
+ *   const {tokens, isExpired, refresh, revoke} = useOAuthTokens()
+ *
+ *   if (!tokens) return <div>Not signed in</div>
+ *
+ *   const handleRefresh = async () => {
+ *     if (!isExpired()) return
+ *     try {
+ *       await refresh()
+ *     } catch {
+ *       // Transient failure (tokens unchanged, retry later) or the refresh
+ *       // token was rejected (tokens now null, user is logged out).
+ *     }
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <p>Expires at {tokens.expiresAt.toLocaleTimeString()}</p>
+ *       <button onClick={handleRefresh}>Refresh if expired</button>
+ *       <button onClick={() => revoke()}>Revoke tokens</button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @public
+ */
+export function useOAuthTokens(): UseOAuthTokensResult {
+  const tokens = useOAuthTokensState()
+  return {
+    tokens,
+    isExpired: () => isOAuthTokenExpired(tokens),
+    refresh: useRefreshOAuthTokens(),
+    revoke: useRevokeOAuthTokens(),
+  }
+}

package/src/hooks/dashboard/useApplication.test.tsx

@@ -0,0 +1,59 @@
+import {installMessageBus, resetMessageBus} from '@sanity/sdk/_internal'
+import {type MessageBusHost, type ValueOf} from '@sanity/sdk/dashboard'
+import {afterEach, beforeEach, describe, expect, expectTypeOf, it, vi} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {useApplication} from './useApplication'
+import {type DashboardApplication} from './useApplications'
+
+const MESSAGE_BUS_KEY = Symbol.for('sanity.os.bus')
+
+let host: MessageBusHost
+
+const application = {
+  id: 'application-1',
+  type: 'coreApp',
+  title: 'Inbox',
+  name: 'inbox',
+  reference: 'sanity/inbox',
+  icon: null,
+  isSingleton: true,
+  visibility: 'default',
+  slug: 'inbox',
+  externalUrl: null,
+  organizationId: 'organization-1',
+  createdAt: '2026-01-01T00:00:00.000Z',
+  updatedAt: '2026-01-02T00:00:00.000Z',
+}
+
+describe('useApplication', () => {
+  beforeEach(() => {
+    // The SDK resolves its own app ID from the CLI-embedded global.
+    vi.stubGlobal('__SANITY_APP_ID__', 'app')
+    host = installMessageBus({appId: 'dashboard'})
+    host.connections.subscribe((client) =>
+      client.emit('applications.list', {
+        ok: true,
+        value: [application],
+      } as ValueOf<'applications.list'>),
+    )
+  })
+
+  afterEach(() => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.unstubAllGlobals()
+  })
+
+  it('returns an application by id or null', () => {
+    const {result, rerender} = renderHook(({applicationId}) => useApplication(applicationId), {
+      initialProps: {applicationId: application.id},
+    })
+
+    expectTypeOf(result.current).toEqualTypeOf<DashboardApplication | null>()
+    expect(result.current?.id).toBe(application.id)
+
+    rerender({applicationId: 'missing'})
+    expect(result.current).toBeNull()
+  })
+})

package/src/hooks/dashboard/useApplication.ts

@@ -0,0 +1,22 @@
+import {type DashboardApplication, useApplications} from './useApplications'
+
+/**
+ * Returns a dashboard application by id, or `null` when it is unavailable.
+ *
+ * Suspends until the dashboard publishes its application list.
+ *
+ * @example
+ * ```tsx
+ * function SelectedApplication({id}: {id: string}) {
+ *   const application = useApplication(id)
+ *   return application ? <h1>{application.title}</h1> : <p>Application unavailable</p>
+ * }
+ * ```
+ *
+ * @public
+ */
+export function useApplication(
+  applicationId: DashboardApplication['id'],
+): DashboardApplication | null {
+  return useApplications().find(({id}) => id === applicationId) ?? null
+}

package/src/hooks/dashboard/useApplicationConfig.test.tsx

@@ -0,0 +1,106 @@
+import {installMessageBus, resetMessageBus} from '@sanity/sdk/_internal'
+import {type ApplicationConfig, type MessageBusHost} from '@sanity/sdk/dashboard'
+import {Suspense} from 'react'
+import {afterEach, beforeEach, describe, expect, expectTypeOf, it, vi} from 'vitest'
+
+import {act, render, renderHook, screen} from '../../../test/test-utils'
+import {type ApplicationConfigSelector, useApplicationConfig} from './useApplicationConfig'
+
+const MESSAGE_BUS_KEY = Symbol.for('sanity.os.bus')
+
+let host: MessageBusHost
+
+// The host writes state to each connection, so publish by emitting to every connection's client.
+const emitConfigs = (value: ApplicationConfig[] | null) =>
+  host.connections.subscribe((client) => client.emit('applications.config', value))
+
+const typeConfig: ApplicationConfig = {
+  appType: 'media-library',
+  entry: 'https://media-library-config.sanity.run',
+  moduleId: 'configs/installation_config',
+  version: '1',
+}
+
+const appConfig: ApplicationConfig = {
+  appId: 'application-1',
+  appType: 'media-library',
+  entry: 'https://application-config.sanity.run',
+  moduleId: 'configs/installation_config',
+  version: '2',
+}
+
+describe('useApplicationConfig', () => {
+  beforeEach(() => {
+    vi.stubGlobal('__SANITY_APP_ID__', 'app')
+    host = installMessageBus({appId: 'dashboard'})
+  })
+
+  afterEach(() => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.unstubAllGlobals()
+    vi.restoreAllMocks()
+  })
+
+  it('selects a config by application type or application id', () => {
+    emitConfigs([typeConfig, appConfig])
+
+    const {result, rerender} = renderHook<
+      {selector: ApplicationConfigSelector},
+      ApplicationConfig | null
+    >(({selector}) => useApplicationConfig(selector), {
+      initialProps: {selector: {appType: 'media-library'}},
+    })
+
+    expectTypeOf(result.current).toEqualTypeOf<ApplicationConfig | null>()
+    expect(result.current).toBe(typeConfig)
+
+    rerender({selector: {appId: 'application-1'}})
+    expect(result.current).toBe(appConfig)
+  })
+
+  it('selects the type-level config for an appType query regardless of emit order', () => {
+    // App-scoped config first: a naive find() would return it for a type query.
+    emitConfigs([appConfig, typeConfig])
+
+    const {result} = renderHook(() => useApplicationConfig({appType: 'media-library'}))
+
+    expect(result.current).toBe(typeConfig)
+  })
+
+  it('returns null when no config matches the selector', () => {
+    emitConfigs([typeConfig, appConfig])
+
+    const {result} = renderHook(() => useApplicationConfig({appId: 'missing'}))
+
+    expect(result.current).toBeNull()
+  })
+
+  it('suspends until the dashboard publishes its configs', async () => {
+    function MediaLibrary() {
+      const config = useApplicationConfig({appType: 'media-library'})
+      return <span>{config?.moduleId ?? 'none'}</span>
+    }
+    render(
+      <Suspense fallback="Loading">
+        <MediaLibrary />
+      </Suspense>,
+    )
+
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      emitConfigs([typeConfig])
+    })
+    expect(await screen.findByText('configs/installation_config')).toBeInTheDocument()
+  })
+
+  it('follows topic updates', () => {
+    emitConfigs([typeConfig])
+    const {result} = renderHook(() => useApplicationConfig({appId: 'application-1'}))
+    expect(result.current).toBeNull()
+
+    act(() => emitConfigs([typeConfig, appConfig]))
+    expect(result.current).toBe(appConfig)
+  })
+})

package/src/hooks/dashboard/useApplicationConfig.ts

@@ -0,0 +1,45 @@
+import {type Application} from '@sanity/sdk'
+import {type ApplicationConfig, type ApplicationConfigAppType} from '@sanity/sdk/dashboard'
+
+import {useApplicationConfigs} from './useApplicationConfigs'
+
+/**
+ * Selects an application configuration by application id or application type.
+ * @public
+ */
+export type ApplicationConfigSelector =
+  | {appId: Application['id']; appType?: never}
+  | {appId?: never; appType: ApplicationConfigAppType}
+
+/**
+ * Returns an application configuration by application id or application type, or `null` when
+ * none matches.
+ *
+ * An `appType` query matches the type-level config only (the one without an `appId`), so it is
+ * independent of the order the dashboard published configs in. An `appId` query matches that
+ * application's config.
+ *
+ * Suspends until the dashboard publishes its application configs.
+ *
+ * @example
+ * ```tsx
+ * function MediaLibraryConfig() {
+ *   const config = useApplicationConfig({appType: 'media-library'})
+ *   return config ? <span>{config.moduleId}</span> : <p>Not installed</p>
+ * }
+ * ```
+ *
+ * @public
+ */
+export function useApplicationConfig(
+  selector: ApplicationConfigSelector,
+): ApplicationConfig | null {
+  const configs = useApplicationConfigs()
+  return (
+    configs.find((config) =>
+      selector.appId === undefined
+        ? config.appType === selector.appType && config.appId === undefined
+        : config.appId === selector.appId,
+    ) ?? null
+  )
+}

package/src/hooks/dashboard/useApplicationConfigs.test.tsx

@@ -0,0 +1,89 @@
+import {installMessageBus, resetMessageBus} from '@sanity/sdk/_internal'
+import {type ApplicationConfig, type MessageBusHost} from '@sanity/sdk/dashboard'
+import {Suspense} from 'react'
+import {afterEach, beforeEach, describe, expect, expectTypeOf, it, vi} from 'vitest'
+
+import {act, render, renderHook, screen} from '../../../test/test-utils'
+import {useApplicationConfigs} from './useApplicationConfigs'
+
+const MESSAGE_BUS_KEY = Symbol.for('sanity.os.bus')
+
+let host: MessageBusHost
+
+// The host writes state to each connection, so publish by emitting to every connection's client.
+const emitConfigs = (value: ApplicationConfig[] | null) =>
+  host.connections.subscribe((client) => client.emit('applications.config', value))
+
+const configs: ApplicationConfig[] = [
+  {
+    appType: 'media-library',
+    entry: 'https://media-library-config.sanity.run',
+    moduleId: 'configs/installation_config',
+    version: '1',
+  },
+  {
+    appId: 'application-1',
+    appType: 'media-library',
+    entry: 'https://application-config.sanity.run',
+    moduleId: 'configs/installation_config',
+    version: '2',
+  },
+]
+
+describe('useApplicationConfigs', () => {
+  beforeEach(() => {
+    vi.stubGlobal('__SANITY_APP_ID__', 'app')
+    host = installMessageBus({appId: 'dashboard'})
+  })
+
+  afterEach(() => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.unstubAllGlobals()
+    vi.restoreAllMocks()
+  })
+
+  it('returns every published application config', () => {
+    emitConfigs(configs)
+
+    const {result} = renderHook(() => useApplicationConfigs())
+
+    expectTypeOf(result.current).toEqualTypeOf<readonly ApplicationConfig[]>()
+    expect(result.current).toEqual(configs)
+  })
+
+  it('suspends until the dashboard publishes its configs', async () => {
+    function Configs() {
+      return <span>{useApplicationConfigs().length} configs</span>
+    }
+    render(
+      <Suspense fallback="Loading">
+        <Configs />
+      </Suspense>,
+    )
+
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      emitConfigs(configs)
+    })
+    expect(await screen.findByText('2 configs')).toBeInTheDocument()
+  })
+
+  it('returns an empty list when the dashboard clears its configs', () => {
+    emitConfigs(null)
+
+    const {result} = renderHook(() => useApplicationConfigs())
+
+    expect(result.current).toEqual([])
+  })
+
+  it('follows topic updates', () => {
+    emitConfigs(null)
+    const {result} = renderHook(() => useApplicationConfigs())
+    expect(result.current).toEqual([])
+
+    act(() => emitConfigs(configs))
+    expect(result.current).toEqual(configs)
+  })
+})

package/src/hooks/dashboard/useApplicationConfigs.ts

@@ -0,0 +1,26 @@
+import {type ApplicationConfig} from '@sanity/sdk/dashboard'
+
+import {useTopic} from './useTopic'
+
+// Stable, frozen reference for the cleared/absent case so the return value only changes with the
+// topic and callers cannot mutate the shared empty list.
+const NO_CONFIGS: readonly ApplicationConfig[] = Object.freeze([])
+
+/**
+ * Returns the application configuration modules available in the dashboard.
+ *
+ * Suspends until the dashboard publishes its application configs; a cleared list is empty.
+ *
+ * @example
+ * ```tsx
+ * function Applications() {
+ *   const configs = useApplicationConfigs()
+ *   return configs.map((config) => <div key={config.moduleId}>{config.appType}</div>)
+ * }
+ * ```
+ *
+ * @public
+ */
+export function useApplicationConfigs(): readonly ApplicationConfig[] {
+  return useTopic('applications.config') ?? NO_CONFIGS
+}