@uniweb/api 1.1.1 → 1.2.1

package/src/elevation.js

@@ -0,0 +1,268 @@
+/**
+ * Elevation — a site's session reads through its roles until it is elevated.
+ *
+ * On a site's backend, a session signed in on the site holds each of the account's roles
+ * as a reader until it is elevated: an administrator reads what their role reaches, and
+ * changes nothing through it. Their own content they edit, delete and share as always.
+ * To act through the role — remove a member's post, grade a submission — the session
+ * elevates, with the password again (and the second factor, when the account has one),
+ * for a while the backend decides (`ELEVATION` in `./wire.js`). No React in this module;
+ * `useElevation` is the hook over it.
+ *
+ * ⭐ **Functions of a client, not methods** — the page's client may have been created by
+ * an older copy of this package (`./mailed-links.js` says why). Everything here reaches
+ * the wire through `request` and keeps its state on the instance.
+ */
+
+import { ApiError } from './errors.js'
+import { composeUrl } from './http.js'
+import { AUTH, ELEVATION } from './wire.js'
+
+/**
+ * `/auth/me`'s `elevation` as the viewer carries it — `{ available, until }`, `until` an
+ * ISO time or `null` — or `null` when the backend sends none: a backend no site reaches,
+ * whose roles answer in full.
+ *
+ * @param {*} raw
+ * @returns {{ available: boolean, until: string|null } | null}
+ */
+export function viewerElevation(raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const until = raw[ELEVATION.until]
+  return Object.freeze({
+    available: raw[ELEVATION.available] === true,
+    until: typeof until === 'string' && until ? until : null,
+  })
+}
+
+/**
+ * Whether a viewer's session is elevated — `until` still ahead, by this clock.
+ *
+ * @param {object|null} viewer - `useSession().viewer`
+ * @param {number} [now]
+ * @returns {boolean}
+ */
+export function isElevated(viewer, now = Date.now()) {
+  const until = viewer?.elevation?.until
+  return typeof until === 'string' && Date.parse(until) > now
+}
+
+/**
+ * Whether a viewer's session acts through its roles now: elevated — or on a backend that
+ * asks for no elevation, whose `/auth/me` carries none and whose roles always answer in
+ * full. False for nobody signed in, and for a viewer read by a copy of this package
+ * older than elevation, which cannot say.
+ *
+ * @param {object|null} viewer
+ * @param {number} [now]
+ * @returns {boolean}
+ */
+export function rolesInFull(viewer, now = Date.now()) {
+  if (!viewer || !('elevation' in viewer)) return false
+  return viewer.elevation === null || isElevated(viewer, now)
+}
+
+/** Whether a cached read is one entity's — whose `can_edit` is the session's answer. */
+const isEntityRead = (spec) => spec?.uuid != null
+
+/**
+ * Ask the backend again who the viewer is, after anything already asking: a probe that
+ * left before the change would answer for the session as it was.
+ */
+async function reprobe(client) {
+  const earlier = client._pending
+  if (earlier) await earlier.catch(() => {})
+  return client.refresh?.()
+}
+
+/**
+ * Elevate the session — the password again, and `code` when the account has a second
+ * factor. Answers `{ until }`, an ISO time. The session is asked again, so `roles` name
+ * what it holds now, and every entity read is read again, since what the viewer may do
+ * to an entity is its own answer (`can_edit`).
+ *
+ * ⚠️ **A wrong password, a wrong code, a missing code and a session that has ended are
+ * one answer, `401`** (`kind: 'auth'`). The session is asked again before the refusal is
+ * thrown, so a session that ended shows as signed out, and one still signed in means
+ * the credential was refused. Nothing on the wire says whether the account has a second
+ * factor: offer the code field to whoever might have one.
+ *
+ * @param {object} client
+ * @param {{ password: string, code?: string }} credentials
+ * @returns {Promise<{ until: string|null }>}
+ * @throws {ApiError} `auth` — refused, as above · `invalid` — no password given
+ */
+export async function elevateWith(client, { password, code } = {}) {
+  if (!password) {
+    throw ApiError.invalid(
+      'No Password',
+      'elevate needs the account’s password — an account with none elevates through its provider (elevateWithProvider)',
+    )
+  }
+  const body = { [ELEVATION.password]: password }
+  if (code != null && code !== '') body[ELEVATION.code] = code
+  let answer
+  try {
+    answer = await client.request('POST', AUTH.elevate, { body, onUnauthorized: 'ignore' })
+  } catch (error) {
+    if (error?.status === 401) await reprobe(client)
+    throw error
+  }
+  client.invalidate?.(isEntityRead)
+  await reprobe(client)
+  return { until: answer?.[ELEVATION.answer] ?? null }
+}
+
+/**
+ * Lower the session before its time runs out. The session is asked again, and every
+ * entity read is read again.
+ *
+ * @param {object} client
+ * @returns {Promise<{ until: null }>}
+ * @throws {ApiError} `auth` — nobody signed in
+ */
+export async function lowerWith(client) {
+  await client.request('DELETE', AUTH.elevate)
+  client.invalidate?.(isEntityRead)
+  await reprobe(client)
+  return { until: null }
+}
+
+/** Marks a `state` as ours, so its echo can be taken off the address bar on the way back. */
+const STATE_PREFIX = 'uw-elevate-'
+
+/** The page's own address, without its query or fragment — where the provider returns to. */
+function pageAddress() {
+  const location = globalThis.location
+  if (!location?.origin || location.origin === 'null') return null
+  return `${location.origin}${location.pathname}`
+}
+
+/**
+ * The provider's elevation for this attempt — for an account with no password — or
+ * `null`: no backend, nobody signed in, no provider named, or no page to return to.
+ *
+ * ⛔ **A navigation, never a fetch**, and one address per attempt: each carries a fresh
+ * `state`, so make it when the viewer asks, never at render.
+ *
+ * @param {object} client
+ * @param {string} provider - the provider's id, as the backend names it (`google`)
+ * @param {{ returnTo?: string }} [options] - the absolute address to come back to; the
+ *   page the viewer is on, without its query or fragment, by default
+ * @returns {string|null}
+ */
+export function elevationAddressOf(client, provider, { returnTo } = {}) {
+  const base = client?.base ?? null
+  if (base === null || !provider || client.session?.status !== 'authenticated') return null
+  const redirect = returnTo || pageAddress()
+  if (!redirect) return null
+  const state = `${STATE_PREFIX}${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`
+  return composeUrl(base, ELEVATION.byProvider(provider), { [ELEVATION.redirect]: redirect, [ELEVATION.state]: state })
+}
+
+/**
+ * Elevate through the account's provider — go to its sign-in, and come back elevated.
+ * Nothing happens outside a browser, or when there is no address to go to
+ * (`elevationAddressOf`).
+ *
+ * @param {object} client
+ * @param {string} provider
+ * @param {{ returnTo?: string }} [options]
+ * @returns {string|null} the address navigated to
+ */
+export function elevateWithProviderOf(client, provider, options) {
+  const address = elevationAddressOf(client, provider, options)
+  if (address && typeof globalThis.location?.assign === 'function') globalThis.location.assign(address)
+  return address
+}
+
+/**
+ * What a provider's elevation came back with, on the page it returned to:
+ * `{ ok: true }`, `{ ok: false, error: 'oauth_step_up_not_linked' }` — the identity that
+ * came back is not this account's — or `null` when the URL carries neither.
+ *
+ * @param {string} [search] - a query string; the page's own by default
+ * @returns {{ ok: boolean, error?: string } | null}
+ */
+export function elevationReturn(search = globalThis.location?.search ?? '') {
+  let params
+  try {
+    params = new URLSearchParams(search)
+  } catch {
+    return null
+  }
+  if (params.get(ELEVATION.returned) === ELEVATION.ok) return Object.freeze({ ok: true })
+  if (params.get(ELEVATION.error) === ELEVATION.notLinked) return Object.freeze({ ok: false, error: ELEVATION.notLinked })
+  return null
+}
+
+/**
+ * Take a provider's answer, and our own `state`, off the address bar — `replaceState`,
+ * no navigation. The rest of the URL stays, another `state` or `error` included.
+ */
+export function forgetElevationReturn() {
+  const location = globalThis.location
+  const history = globalThis.history
+  if (!location || typeof history?.replaceState !== 'function') return
+  const params = new URLSearchParams(location.search)
+  let changed = false
+  if (params.get(ELEVATION.returned) === ELEVATION.ok) {
+    params.delete(ELEVATION.returned)
+    changed = true
+  }
+  if (params.get(ELEVATION.error) === ELEVATION.notLinked) {
+    params.delete(ELEVATION.error)
+    changed = true
+  }
+  if (params.get(ELEVATION.state)?.startsWith(STATE_PREFIX)) {
+    params.delete(ELEVATION.state)
+    changed = true
+  }
+  if (!changed) return
+  const query = params.toString()
+  history.replaceState(history.state, '', `${location.pathname}${query ? `?${query}` : ''}${location.hash}`)
+}
+
+/**
+ * A provider's answer, read ONCE per page and taken off the address bar — the same
+ * answer to every component that asks.
+ *
+ * @param {object} client
+ * @returns {{ ok: boolean, error?: string } | null}
+ */
+export function takeElevationReturn(client) {
+  if (!client) return null
+  if (client._elevationReturn === undefined) {
+    client._elevationReturn = elevationReturn()
+    if (client._elevationReturn) forgetElevationReturn()
+  }
+  return client._elevationReturn
+}
+
+/**
+ * Ask the backend again when the session's elevation runs out, so `roles` stop naming
+ * what it no longer holds — one timer per client, armed for the `until` the session
+ * carries, and let go when that changes or the session ends.
+ *
+ * ⚠️ `until` is the backend's clock and the timer is this one's. Behind, the probe comes
+ * late. Ahead, the probe finds the session still elevated at an `until` this clock has
+ * passed, and arms nothing: the page's next probe tells.
+ *
+ * @param {object} client
+ */
+export function watchLapse(client) {
+  const until = client?.session?.viewer?.elevation?.until ?? null
+  if (client._lapse && client._lapse.until === until) return
+  if (client._lapse) clearTimeout(client._lapse.timer)
+  client._lapse = null
+  if (!until || typeof setTimeout !== 'function') return
+  const wait = Date.parse(until) - Date.now()
+  if (!(wait > 0)) return
+  // A second past `until`, and never longer than a timer can wait.
+  const timer = setTimeout(() => {
+    client._lapse = null
+    client.refresh?.()
+  }, Math.min(wait + 1000, 2 ** 31 - 1))
+  timer?.unref?.()
+  client._lapse = { until, timer }
+}

package/src/hooks/useChoices.js

@@ -0,0 +1,102 @@
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react'
+import { getClient } from '../client.js'
+
+const noSubscribe = () => () => {}
+const noSnapshot = () => null
+const NONE = Object.freeze([])
+
+/**
+ * The choices a field offers — a page of its list, for a dropdown or a type-ahead.
+ *
+ * ```jsx
+ * const [q, setQ] = useState('')
+ * const { status, items } = useChoices({ schema: '@acme/cv', field: 'country', q, searchIn: 'label' })
+ * // items[i].uuid is the value to store in `country`; items[i].data.label what to show
+ *
+ * // a dependent list: the provinces of the country chosen above
+ * const provinces = useChoices(country ? { schema: '@acme/cv', field: 'province', parent: country } : null)
+ * ```
+ *
+ * `field` is a field of kind `item_ref` (`options:` in a schema); `listChoices` says
+ * what each parameter does. A page is `limit` items (50 by default): pass `nextCursor`
+ * back as `cursor` for the next. ⚠️ A searched page can be short while more follow —
+ * `hasMore` is the end signal, never the page's length.
+ *
+ * `absent` — no `backend` service, or nobody signed in. Cached under a key scoped to the
+ * viewer; a list edited elsewhere is read again by `refresh`.
+ *
+ * @param {{ schema: string, field: string, section?: string, parent?: string, q?: string, searchIn?: string, cursor?: string, limit?: number } | null} query
+ *   pass null to skip
+ * @returns {{ status: string, items: object[], nextCursor: string|null, hasMore: boolean, error: Error|null, refresh: Function }}
+ */
+export function useChoices(query) {
+  const client = getClient()
+  const store = client?.website?.dataStore ?? null
+
+  const session = useSyncExternalStore(
+    client ? client.subscribe : noSubscribe,
+    client ? () => client.session : noSnapshot,
+    client ? () => client.session : noSnapshot,
+  )
+
+  const active = !!(
+    client &&
+    client.enabled &&
+    store &&
+    query &&
+    query.schema &&
+    query.field &&
+    session?.status !== 'anonymous'
+  )
+  const spec = active
+    ? {
+        endpoint: '/sections',
+        schema: query.schema,
+        field: query.field,
+        section: query.section,
+        parent: query.parent,
+        q: query.q || undefined,
+        searchIn: query.searchIn,
+        cursor: query.cursor,
+        limit: query.limit,
+      }
+    : null
+  const key = spec ? client.cacheKey(spec) : null
+
+  const subscribe = useCallback((fn) => (key ? store.subscribe(key, fn) : noSubscribe()), [store, key])
+  const entry = useSyncExternalStore(
+    subscribe,
+    () => (key ? store.get(key) : null),
+    () => (key ? store.get(key) : null),
+  )
+
+  const [error, setError] = useState(null)
+  const [attempt, setAttempt] = useState(0)
+
+  useEffect(() => {
+    if (!key || entry) return undefined
+    let live = true
+    setError(null)
+    client.load(key, () => client.listChoices(query), spec).catch((err) => {
+      if (live) setError(err)
+    })
+    return () => {
+      live = false
+    }
+    // `query` is read through `key`, which encodes every part of it.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [client, key, entry, attempt])
+
+  const refresh = useCallback(() => {
+    if (key && store) store.delete(key)
+    setAttempt((n) => n + 1)
+  }, [store, key])
+
+  const empty = { items: NONE, nextCursor: null, hasMore: false }
+  if (!active) return { status: 'absent', ...empty, error: null, refresh }
+  if (entry) return { status: 'ready', ...entry.data, error: null, refresh }
+  if (error) return { status: 'error', ...empty, error, refresh }
+  return { status: 'loading', ...empty, error: null, refresh }
+}
+
+export default useChoices

package/src/hooks/useDefinition.js

@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react'
+import { getClient } from '../client.js'
+
+const noSubscribe = () => () => {}
+const noSnapshot = () => null
+
+/**
+ * A Model's definition — the sections and fields a form is built from.
+ *
+ * ```jsx
+ * const { status, definition } = useDefinition('@acme/cv')
+ * if (status !== 'ready') return null
+ * const brief = definition.sections.find((s) => s.brief)
+ * // brief.fields → [{ key: 'title', kind: 'string', required: true, max_length: 250 }, …]
+ * ```
+ *
+ * Each field is its declaration as the backend stores it, with `enum` folded in from its
+ * section's rules (`readDefinition`). The rules a definition states are the rules every
+ * write is checked against.
+ *
+ * `absent` — no `backend` service, or nobody signed in: a definition is read by someone
+ * signed in. Cached under a key scoped to the viewer.
+ *
+ * @param {string|null} schema - the Model, e.g. `@acme/cv`; null to skip
+ * @returns {{ status: string, definition: object|null, error: Error|null, refresh: Function }}
+ */
+export function useDefinition(schema) {
+  const client = getClient()
+  const store = client?.website?.dataStore ?? null
+
+  const session = useSyncExternalStore(
+    client ? client.subscribe : noSubscribe,
+    client ? () => client.session : noSnapshot,
+    client ? () => client.session : noSnapshot,
+  )
+
+  const active = !!(client && client.enabled && store && schema && session?.status !== 'anonymous')
+  const spec = active ? { endpoint: '/models', schema } : null
+  const key = spec ? client.cacheKey(spec) : null
+
+  const subscribe = useCallback((fn) => (key ? store.subscribe(key, fn) : noSubscribe()), [store, key])
+  const entry = useSyncExternalStore(
+    subscribe,
+    () => (key ? store.get(key) : null),
+    () => (key ? store.get(key) : null),
+  )
+
+  const [error, setError] = useState(null)
+  const [attempt, setAttempt] = useState(0)
+
+  useEffect(() => {
+    if (!key || entry) return undefined
+    let live = true
+    setError(null)
+    client.load(key, () => client.readDefinition({ schema }), spec).catch((err) => {
+      if (live) setError(err)
+    })
+    return () => {
+      live = false
+    }
+    // `schema` is read through `key`, which encodes it.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [client, key, entry, attempt])
+
+  const refresh = useCallback(() => {
+    if (key && store) store.delete(key)
+    // The client keeps the definition too; a refresh reads it from the backend again.
+    if (schema) client?.forgetDefinition(schema)
+    setAttempt((n) => n + 1)
+  }, [store, key, client, schema])
+
+  if (!active) return { status: 'absent', definition: null, error: null, refresh }
+  if (entry) return { status: 'ready', definition: entry.data, error: null, refresh }
+  if (error) return { status: 'error', definition: null, error, refresh }
+  return { status: 'loading', definition: null, error: null, refresh }
+}
+
+export default useDefinition

package/src/hooks/useElevation.js

@@ -0,0 +1,147 @@
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react'
+import { getClient } from '../client.js'
+import { ApiError } from '../errors.js'
+import { elevateWith, lowerWith, elevateWithProviderOf, takeElevationReturn, rolesInFull } from '../elevation.js'
+import { useAction } from './useAction.js'
+
+const NONE = Object.freeze({ status: 'anonymous', viewer: null, error: null })
+const noSubscribe = () => () => {}
+const noSnapshot = () => NONE
+
+/**
+ * Elevation — whether the viewer's session acts through their roles, and the calls that
+ * change it.
+ *
+ * On a site's backend a session holds each of the account's roles as a reader until it
+ * is elevated: an administrator reads what their role reaches and changes nothing
+ * through it — their own content they edit, delete and share as always. To act through
+ * the role, they confirm it is them, and the session is elevated for a while.
+ *
+ * ```jsx
+ * const { available, elevated, until, elevate, lower, status, error } = useElevation()
+ * if (available && !elevated) return <ConfirmPassword onSubmit={(password, code) => elevate({ password, code })} />
+ * if (elevated) return <p>Acting as administrator until {new Date(until).toLocaleTimeString()}. <button onClick={lower}>Stop</button></p>
+ * ```
+ *
+ * - **`available`** — the account holds a role that answers more than reading: offer
+ *   elevation only then.
+ * - **`elevated`** — true while it lasts; `until` is when it ends, an ISO time. It turns
+ *   false by itself when the time passes, and the session is asked again then. Elevating
+ *   again starts the time again; nothing extends it on its own.
+ * - **`rolesInFull`** — whether the session acts through its roles now: elevated, or on a
+ *   backend that never asks for it. Draw controls that act through a role from this, and
+ *   ask each entity what the viewer may do to it — `useEntity`'s `entity.can_edit`, read
+ *   again after every change here.
+ * - **`elevate({ password, code })`** — `code` when the account has a second factor.
+ *   Nothing says whether it has one, so offer the field to whoever might. A refusal is
+ *   `kind: 'auth'`, one answer for a wrong password or code; a session that has ended
+ *   shows as signed out first.
+ * - **`elevateWithProvider(provider)`** — for an account with no password: a navigation
+ *   to the provider's sign-in, which comes back to this page. If the identity that comes
+ *   back is not this account's, `error` says so — `kind: 'auth'`,
+ *   `error.extensions.reason === 'oauth_step_up_not_linked'`.
+ * - **`lower()`** — ends it early.
+ *
+ * Elevating does not open the backend's administration — the Admin link does
+ * (`useSession().adminHref`). On a site with no backend, or with nobody signed in,
+ * nothing is available.
+ *
+ * @returns {{
+ *   available: boolean,
+ *   elevated: boolean,
+ *   until: string | null,
+ *   rolesInFull: boolean,
+ *   elevate: (credentials: { password: string, code?: string }) => Promise<{ until: string|null }>,
+ *   elevateWithProvider: (provider: string, options?: { returnTo?: string }) => string | null,
+ *   lower: () => Promise<{ until: null }>,
+ *   status: 'idle' | 'submitting' | 'success' | 'error',
+ *   error: Error | null,
+ *   reset: () => void,
+ * }}
+ */
+export function useElevation() {
+  const client = getClient()
+  const session = useSyncExternalStore(
+    client ? client.subscribe : noSubscribe,
+    client ? () => client.session : noSnapshot,
+    client ? () => client.session : noSnapshot,
+  )
+  const viewer = session.status === 'authenticated' ? session.viewer : null
+  const elevation = viewer?.elevation ?? null
+  const until = elevation?.until ?? null
+
+  // Ask who the viewer is, as `useSession` does — this hook may be the only one asking.
+  useEffect(() => {
+    if (client && client.enabled) client.ensureSession()
+  }, [client])
+
+  // Render again when the elevation runs out, so `elevated` turns false on time.
+  const [, setTick] = useState(0)
+  useEffect(() => {
+    if (!until) return undefined
+    const wait = Date.parse(until) - Date.now()
+    if (!(wait > 0)) return undefined
+    const timer = setTimeout(() => setTick((n) => n + 1), Math.min(wait + 50, 2 ** 31 - 1))
+    return () => clearTimeout(timer)
+  }, [until])
+
+  const { run, status, error, reset } = useAction(
+    useCallback(
+      async (step, arg) => {
+        if (!client) throw ApiError.disabled()
+        return step === 'lower' ? lowerWith(client) : elevateWith(client, arg)
+      },
+      [client],
+    ),
+  )
+
+  // A provider's elevation returns to the page: read once, in an effect — the URL is the
+  // browser's, never the server render's. Coming back elevated needs nothing here: the
+  // session says so.
+  const [returned, setReturned] = useState(null)
+  useEffect(() => {
+    const answer = takeElevationReturn(client)
+    if (answer && !answer.ok) {
+      setReturned(
+        new ApiError({
+          status: 0,
+          title: 'Not Linked',
+          detail: 'the identity the provider returned is not this account’s',
+          kind: 'auth',
+          extensions: { reason: answer.error },
+        }),
+      )
+    }
+  }, [client])
+
+  const elevate = useCallback((credentials) => run('elevate', credentials), [run])
+  const lower = useCallback(() => run('lower'), [run])
+  const elevateWithProvider = useCallback(
+    (provider, options) => {
+      setReturned(null)
+      return client ? elevateWithProviderOf(client, provider, options) : null
+    },
+    [client],
+  )
+  const clear = useCallback(() => {
+    setReturned(null)
+    reset()
+  }, [reset])
+
+  const elevated = typeof until === 'string' && Date.parse(until) > Date.now()
+
+  return {
+    available: elevation?.available === true,
+    elevated,
+    until: elevated ? until : null,
+    rolesInFull: rolesInFull(viewer),
+    elevate,
+    elevateWithProvider,
+    lower,
+    status,
+    error: error ?? (status === 'idle' ? returned : null),
+    reset: clear,
+  }
+}
+
+export default useElevation

package/src/hooks/useRecords.js

@@ -35,8 +35,8 @@ const DISABLED = Object.freeze({ status: 'absent', records: NONE, matched: 0, ha
  * `hasMore` is true when the page came back full.
  *
  * The default scope is everything the viewer may read — signed in on a site, their
- * own entities and what was shared with them, the operator included.
- * `scope: 'mine'` is only the viewer's own.
+ * own entities, what was shared with them, and what a role of theirs reaches: the
+ * operator's, every member's. `scope: 'mine'` is only the viewer's own.
  *
  * Cached under a key scoped to the viewer, so a sign-in re-reads the list for who
  * is now looking, and a write through `useEntityWriter` drops it.

package/src/hooks/useSession.js

@@ -15,6 +15,11 @@ const noop = async () => NONE
  * affordance on false. `error` is set when the backend could not be asked;
  * `refresh()` asks again.
  *
+ * `viewer.roles` describe the session, not the account: on a site's backend an
+ * administrator's session holds its roles as a reader until it is elevated, and
+ * `viewer.elevation` — `{ available, until }`, or `null` on a backend that never asks —
+ * says whether it can be, and until when it is. `useElevation` reads it and elevates.
+ *
  * `adminHref` is the Admin link — set only for a signed-in account the backend's
  * administration admits, `null` for everyone else, so draw the link only when it is
  * set. ⛔ Navigate to it, never `fetch` it (`adminHrefOf` in `../client.js`).

package/src/index.js

@@ -18,6 +18,11 @@ export {
   signIn,
   completeChallenge,
   signOut,
+  elevate,
+  lower,
+  elevateWithProvider,
+  isElevated,
+  rolesInFull,
   signUp,
   requestPasswordReset,
   confirmPasswordReset,
@@ -30,6 +35,9 @@ export {
   forgetMailedLink,
   readEntity,
   listEntities,
+  readDefinition,
+  listSectionItems,
+  listChoices,
   writeItems,
   createEntity,
   deleteEntity,
@@ -39,6 +47,7 @@ export {
 } from './client.js'
 
 export { useSession } from './hooks/useSession.js'
+export { useElevation } from './hooks/useElevation.js'
 export { useSignIn } from './hooks/useSignIn.js'
 export { useSignUp } from './hooks/useSignUp.js'
 export { usePasswordReset } from './hooks/usePasswordReset.js'
@@ -46,5 +55,7 @@ export { useMailedLink } from './hooks/useMailedLink.js'
 export { useInvitations } from './hooks/useInvitations.js'
 export { useEntity } from './hooks/useEntity.js'
 export { useRecords } from './hooks/useRecords.js'
+export { useDefinition } from './hooks/useDefinition.js'
+export { useChoices } from './hooks/useChoices.js'
 export { useEntityWriter } from './hooks/useEntityWriter.js'
 export { SignedIn, SignedOut } from './components/gates.js'