@byline/host-tanstack-start 3.10.0 → 3.11.0

package/src/admin-shell/admin-activity/list.tsx

@@ -0,0 +1,242 @@
+'use client'
+
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { useRouterState } from '@tanstack/react-router'
+
+import { getClientConfig } from '@byline/core'
+import { useTranslation } from '@byline/i18n/react'
+import { Button, Container, Section, Select, Table } from '@byline/ui/react'
+import cx from 'classnames'
+
+import { Link, useNavigate } from '../chrome/loose-router.js'
+import { RouterPager } from '../chrome/router-pager.js'
+import styles from './list.module.css'
+import type { SystemActivityResponse } from '../../server-fns/admin-activity/index.js'
+
+/**
+ * Namespaced audit `action` → i18n label key. Covers the version-stream's
+ * synthesised content-save actions (`document.created` / `document.updated`)
+ * as well as the audit-log actions surfaced on the per-document history tab.
+ * Unknown actions fall back to the raw value rather than a missing-key warning.
+ */
+const ACTION_KEYS: Record<string, string> = {
+  'document.created': 'activity.actions.created',
+  'document.updated': 'activity.actions.updated',
+  'document.path.changed': 'activity.actions.pathChanged',
+  'document.locales.changed': 'activity.actions.localesChanged',
+  'document.status.changed': 'activity.actions.statusChanged',
+  'document.deleted': 'activity.actions.deleted',
+}
+
+/** The selectable action types, in display order. `_all` clears the filter. */
+const ACTION_FILTER_VALUES = [
+  'document.created',
+  'document.updated',
+  'document.status.changed',
+  'document.path.changed',
+  'document.locales.changed',
+  'document.deleted',
+] as const
+
+/** Render an audit before/after value inline: arrays comma-join, nullish → em-dash. */
+function formatAuditValue(value: unknown): string {
+  if (value == null) return '—'
+  if (Array.isArray(value)) return value.length > 0 ? value.join(', ') : '—'
+  return String(value)
+}
+
+/**
+ * The system-wide activity report (docs/AUDIT.md — Workstream 4): a paged,
+ * filterable feed over the union of the version stream (content saves) and the
+ * audit log (status / path / locale changes, deletions, and future admin-realm
+ * events). Read-only; gated by `admin.activity.read`.
+ */
+export const ActivitySystemView = ({ data }: { data: SystemActivityResponse }) => {
+  const { t } = useTranslation('byline-admin')
+  const navigate = useNavigate()
+  const location = useRouterState({ select: (s) => s.location })
+  const search = location.search as {
+    collection?: string
+    action?: string
+    page?: number
+  }
+
+  const entries = data?.entries ?? []
+  const collections = getClientConfig().collections
+
+  // Navigate with the changed filter merged into the URL search; clearing the
+  // page so a filter change always lands on page 1. `_all` removes the filter.
+  const applyFilter = (key: 'collection' | 'action', value: string) => {
+    const params = structuredClone(location.search) as Record<string, unknown>
+    params.page = undefined
+    if (value === '_all') {
+      params[key] = undefined
+    } else {
+      params[key] = value
+    }
+    navigate({ to: '/admin/activity' as never, search: params })
+  }
+
+  const collectionItems = [
+    { value: '_all', label: t('activity.filters.allCollections') },
+    ...collections.map((c) => ({
+      value: c.path,
+      label: (c.labels?.plural as string) ?? c.path,
+    })),
+  ]
+
+  const actionItems = [
+    { value: '_all', label: t('activity.filters.allActions') },
+    ...ACTION_FILTER_VALUES.map((a) => ({
+      value: a,
+      label: ACTION_KEYS[a] ? t(ACTION_KEYS[a]) : a,
+    })),
+  ]
+
+  const hasFilters = search.collection != null || search.action != null
+
+  return (
+    <Section>
+      <Container>
+        <div className={cx('byline-activity-head', styles.head)}>
+          <h1 className={cx('byline-activity-title', styles.title)}>{t('activity.title')}</h1>
+        </div>
+
+        <div className={cx('byline-activity-options', styles.options)}>
+          <Select<string>
+            id="activity_collection_filter"
+            name="activity_collection_filter"
+            size="sm"
+            value={search.collection ?? '_all'}
+            items={collectionItems}
+            onValueChange={(v) => {
+              if (typeof v === 'string') applyFilter('collection', v)
+            }}
+          />
+          <Select<string>
+            id="activity_action_filter"
+            name="activity_action_filter"
+            size="sm"
+            value={search.action ?? '_all'}
+            items={actionItems}
+            onValueChange={(v) => {
+              if (typeof v === 'string') applyFilter('action', v)
+            }}
+          />
+          {hasFilters && (
+            <Button
+              size="sm"
+              variant="text"
+              onClick={() => navigate({ to: '/admin/activity' as never, search: {} })}
+            >
+              {t('activity.filters.clear')}
+            </Button>
+          )}
+          <RouterPager
+            page={data.meta.page}
+            count={data.meta.totalPages}
+            showFirstButton
+            showLastButton
+            componentName="pagerTop"
+            aria-label={t('activity.pagerAriaLabel')}
+          />
+        </div>
+
+        {entries.length === 0 ? (
+          <p className={cx('byline-activity-empty', styles.empty)}>{t('activity.empty')}</p>
+        ) : (
+          <Table.Container className={cx('byline-activity-table-wrap', styles.tableWrap)}>
+            <Table>
+              <Table.Header>
+                <Table.Row>
+                  <Table.HeadingCell scope="col">{t('activity.columns.when')}</Table.HeadingCell>
+                  <Table.HeadingCell scope="col">
+                    {t('activity.columns.collection')}
+                  </Table.HeadingCell>
+                  <Table.HeadingCell scope="col">{t('activity.columns.action')}</Table.HeadingCell>
+                  <Table.HeadingCell scope="col">{t('activity.columns.actor')}</Table.HeadingCell>
+                  <Table.HeadingCell scope="col">{t('activity.columns.change')}</Table.HeadingCell>
+                </Table.Row>
+              </Table.Header>
+              <Table.Body>
+                {entries.map((entry) => {
+                  const actionKey = ACTION_KEYS[entry.action]
+                  const actionLabel = actionKey ? t(actionKey) : entry.action
+                  // System/tooling write (NULL actor or 'system' realm) → the
+                  // system label; an unresolved id is a deleted user; otherwise
+                  // the admin-resolved label.
+                  const actorLabel =
+                    entry.actorId == null || entry.actorRealm === 'system'
+                      ? t('activity.systemActor')
+                      : (data.actors?.[entry.actorId]?.label ?? t('activity.formerUser'))
+
+                  const col = entry.collectionId ? data.collections[entry.collectionId] : undefined
+                  const collectionLabel = col?.plural ?? col?.path ?? '—'
+
+                  const hasChange = entry.before != null || entry.after != null
+
+                  return (
+                    <Table.Row key={entry.id}>
+                      <Table.Cell className={cx('byline-activity-when', styles.when)}>
+                        {new Date(entry.occurredAt).toLocaleString()}
+                      </Table.Cell>
+                      <Table.Cell>
+                        {col != null && entry.documentId != null ? (
+                          <Link
+                            to={'/admin/collections/$collection/$id' as never}
+                            params={{ collection: col.path, id: entry.documentId }}
+                          >
+                            {collectionLabel}
+                          </Link>
+                        ) : (
+                          collectionLabel
+                        )}
+                      </Table.Cell>
+                      <Table.Cell>{actionLabel}</Table.Cell>
+                      <Table.Cell>{actorLabel}</Table.Cell>
+                      <Table.Cell className={cx('byline-activity-change', styles.change)}>
+                        {hasChange ? (
+                          <>
+                            <span className={cx('byline-activity-before', styles.before)}>
+                              {formatAuditValue(entry.before)}
+                            </span>
+                            <span className={cx('byline-activity-arrow', styles.arrow)}>
+                              {' → '}
+                            </span>
+                            <span className={cx('byline-activity-after', styles.after)}>
+                              {formatAuditValue(entry.after)}
+                            </span>
+                          </>
+                        ) : (
+                          '—'
+                        )}
+                      </Table.Cell>
+                    </Table.Row>
+                  )
+                })}
+              </Table.Body>
+            </Table>
+          </Table.Container>
+        )}
+
+        <div className={cx('byline-activity-options', styles.options)}>
+          <RouterPager
+            page={data.meta.page}
+            count={data.meta.totalPages}
+            showFirstButton
+            showLastButton
+            componentName="pagerBottom"
+            aria-label={t('activity.pagerAriaLabel')}
+          />
+        </div>
+      </Container>
+    </Section>
+  )
+}

package/src/admin-shell/chrome/menu-drawer.tsx

@@ -9,11 +9,20 @@
 import type React from 'react'
 import { useRouterState } from '@tanstack/react-router'
 
+import { ADMIN_ACTIVITY_ABILITIES } from '@byline/admin/admin-activity'
 import { ADMIN_PERMISSIONS_ABILITIES } from '@byline/admin/admin-permissions'
 import { ADMIN_ROLES_ABILITIES } from '@byline/admin/admin-roles'
 import { ADMIN_USERS_ABILITIES } from '@byline/admin/admin-users'
 import { useTranslation } from '@byline/i18n/react'
-import { HomeIcon, RolesIcon, SettingsSlidersIcon, UserIcon, UsersIcon } from '@byline/ui/react'
+import {
+  ActivityIcon,
+  HomeIcon,
+  RolesIcon,
+  SettingsSlidersIcon,
+  Tooltip,
+  UserIcon,
+  UsersIcon,
+} from '@byline/ui/react'
 import cx from 'classnames'
 import { useSwipeable } from 'react-swipeable'
 
@@ -39,10 +48,22 @@ interface MenuItemProps {
 }
 
 function MenuItem({ to, label, icon, pathname, compact }: MenuItemProps) {
+  // In the compact (icon-only) state the label text is hidden, so a tooltip on
+  // the icon is the only way to discover what the item is. When labels are
+  // visible the tooltip would be redundant, so it's gated on `compact`. The
+  // span is the trigger (not the bare icon) so the ref / hover handlers Base UI
+  // merges always land on a DOM node regardless of how each icon forwards props.
+  const iconSpan = <span className="icon">{icon}</span>
   return (
     <li className={cx('menu-item', { active: isActive(pathname, to), compact })}>
       <Link to={to}>
-        <span className="icon">{icon}</span>
+        {compact ? (
+          <Tooltip text={label} side="right">
+            {iconSpan}
+          </Tooltip>
+        ) : (
+          iconSpan
+        )}
         <span className="label">{label}</span>
       </Link>
     </li>
@@ -63,7 +84,8 @@ export function AdminMenuDrawer(): React.JSX.Element | null {
   const canReadUsers = has(ADMIN_USERS_ABILITIES.read)
   const canReadRoles = has(ADMIN_ROLES_ABILITIES.read)
   const canReadPermissions = has(ADMIN_PERMISSIONS_ABILITIES.read)
-  const showAdminSection = canReadUsers || canReadRoles || canReadPermissions
+  const canReadActivity = has(ADMIN_ACTIVITY_ABILITIES.read)
+  const showAdminSection = canReadUsers || canReadRoles || canReadPermissions || canReadActivity
 
   const handlers = useSwipeable({
     onSwipedLeft: () => {
@@ -133,6 +155,15 @@ export function AdminMenuDrawer(): React.JSX.Element | null {
                   compact={compact}
                 />
               )}
+              {canReadActivity && (
+                <MenuItem
+                  to="/admin/activity"
+                  label={t('chrome.menu.activity')}
+                  icon={<ActivityIcon width="20px" height="20px" />}
+                  pathname={pathname}
+                  compact={compact}
+                />
+              )}
             </>
           )}
           <li className="menu-separator" />

package/src/admin-shell/chrome/preview-toggle.tsx

@@ -24,7 +24,7 @@
 import { useEffect, useState } from 'react'
 
 import { useTranslation } from '@byline/i18n/react'
-import { EyeClosedIcon, EyeOpenIcon } from '@byline/ui/react'
+import { EyeClosedIcon, EyeOpenIcon, Tooltip } from '@byline/ui/react'
 import cx from 'classnames'
 
 import {
@@ -89,6 +89,7 @@ export function PreviewToggle({ compact }: PreviewToggleProps) {
   ) : (
     <EyeClosedIcon width="20px" height="20px" />
   )
+  const iconSpan = <span className="icon">{icon}</span>
 
   return (
     <li className={cx('menu-item byline-preview-toggle', { compact, active: preview })}>
@@ -99,9 +100,19 @@ export function PreviewToggle({ compact }: PreviewToggleProps) {
         aria-label={
           preview ? t('chrome.preview.disableAriaLabel') : t('chrome.preview.enableAriaLabel')
         }
-        title={preview ? t('chrome.preview.onTitle') : t('chrome.preview.offTitle')}
+        // Native title for the expanded state; in compact mode the styled
+        // Tooltip below takes over so the two don't fire at once.
+        title={
+          compact ? undefined : preview ? t('chrome.preview.onTitle') : t('chrome.preview.offTitle')
+        }
       >
-        <span className="icon">{icon}</span>
+        {compact ? (
+          <Tooltip text={label} side="right">
+            {iconSpan}
+          </Tooltip>
+        ) : (
+          iconSpan
+        )}
         <span className="label">{label}</span>
       </button>
     </li>

package/src/routes/create-admin-activity-route.tsx

@@ -0,0 +1,76 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { createFileRoute } from '@tanstack/react-router'
+
+import { useTranslation } from '@byline/i18n/react'
+import { z } from 'zod'
+
+import { ActivitySystemView } from '../admin-shell/admin-activity/list.js'
+import { BreadcrumbsClient } from '../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js'
+import { getSystemActivityLog } from '../server-fns/admin-activity/index.js'
+import type { SystemActivityResponse } from '../server-fns/admin-activity/index.js'
+
+const searchSchema = z.object({
+  page: z.coerce.number().int().min(1).optional(),
+  page_size: z.coerce.number().int().min(1).max(100).optional(),
+  collection: z.string().optional(),
+  action: z.string().optional(),
+  actorId: z.string().optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+})
+
+type ActivitySearch = z.infer<typeof searchSchema>
+
+export function createAdminActivityRoute(path: string) {
+  // biome-ignore lint/suspicious/noExplicitAny: dynamic path bypasses route-tree typing
+  const Route: any = createFileRoute(path as never)({
+    validateSearch: searchSchema,
+    loaderDeps: ({ search }: { search: ActivitySearch }) => ({
+      page: search.page,
+      page_size: search.page_size,
+      collection: search.collection,
+      action: search.action,
+      actorId: search.actorId,
+      from: search.from,
+      to: search.to,
+    }),
+    loader: async ({ deps }: { deps: ActivitySearch }) => {
+      const data = await getSystemActivityLog({
+        data: {
+          page: deps.page,
+          page_size: deps.page_size,
+          collection: deps.collection,
+          action: deps.action,
+          actorId: deps.actorId,
+          from: deps.from,
+          to: deps.to,
+        },
+      })
+      return { data }
+    },
+    component: function AdminActivityComponent() {
+      const { data } = Route.useLoaderData() as { data: SystemActivityResponse }
+      const { t } = useTranslation('byline-admin')
+      return (
+        <>
+          <BreadcrumbsClient
+            breadcrumbs={[
+              { label: t('chrome.menu.dashboard'), href: '/admin' },
+              { label: t('activity.title'), href: '/admin/activity' },
+            ]}
+          />
+          <ActivitySystemView data={data} />
+        </>
+      )
+    },
+  })
+
+  return Route
+}

package/src/routes/index.ts

@@ -21,6 +21,7 @@
  */
 
 export { createAdminAccountRoute } from './create-admin-account-route.js'
+export { createAdminActivityRoute } from './create-admin-activity-route.js'
 export { createAdminDashboardRoute } from './create-admin-dashboard-route.js'
 export { createAdminLayoutRoute } from './create-admin-layout-route.js'
 export { createAdminPermissionsRoute } from './create-admin-permissions-route.js'

package/src/server-fns/admin-account/change-password.ts

@@ -20,7 +20,7 @@ export interface ChangeAccountPasswordInput {
 }
 
 export const changeAccountPassword = createServerFn({ method: 'POST' })
-  .inputValidator((input: ChangeAccountPasswordInput) => input)
+  .validator((input: ChangeAccountPasswordInput) => input)
   .handler(async ({ data }): Promise<AccountResponse> => {
     const context = await getAdminRequestContext()
     return changeAccountPasswordCommand(context, data, { store: bylineCore().adminStore! })

package/src/server-fns/admin-account/get.ts

@@ -20,7 +20,7 @@ import { bylineCore } from '../../integrations/byline-core.js'
  * doesn't carry.
  */
 export const getAccount = createServerFn({ method: 'GET' })
-  .inputValidator((input?: Record<string, never>) => input ?? {})
+  .validator((input?: Record<string, never>) => input ?? {})
   .handler(async ({ data }): Promise<AccountResponse> => {
     const context = await getAdminRequestContext()
     return getAccountCommand(context, data, { store: bylineCore().adminStore! })

package/src/server-fns/admin-account/update.ts

@@ -24,7 +24,7 @@ export interface UpdateAccountInput {
 }
 
 export const updateAccount = createServerFn({ method: 'POST' })
-  .inputValidator((input: UpdateAccountInput) => input)
+  .validator((input: UpdateAccountInput) => input)
   .handler(async ({ data }): Promise<AccountResponse> => {
     const context = await getAdminRequestContext()
     return updateAccountCommand(context, data, { store: bylineCore().adminStore! })

package/src/server-fns/admin-activity/get.ts

@@ -0,0 +1,139 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+import { createServerFn } from '@tanstack/react-start'
+
+import { assertAdminActor } from '@byline/admin'
+import { ADMIN_ACTIVITY_ABILITIES } from '@byline/admin/admin-activity'
+import { ERR_AUDIT_UNSUPPORTED, getLogger, getServerConfig } from '@byline/core'
+
+import { getAdminRequestContext } from '../../auth/auth-context.js'
+import { type ActorLabelMap, resolveActorLabels } from '../collections/actors.js'
+import type { AuditLogEntryDto } from '../collections/audit.js'
+
+// ---------------------------------------------------------------------------
+// System-wide activity report (docs/AUDIT.md — Workstream 4)
+// ---------------------------------------------------------------------------
+
+/** Filters for the activity feed. `from` / `to` are ISO strings over the wire. */
+export interface SystemActivitySearchParams {
+  actorId?: string
+  /** Collection **path** (the admin works in paths; the handler resolves it to the stored collection id). */
+  collection?: string
+  action?: string
+  from?: string
+  to?: string
+  page?: number
+  page_size?: number
+}
+
+/** Collection display info, captured at query time (a row may name a collection that was later renamed/removed). */
+export interface ActivityCollectionInfo {
+  path: string
+  singular: string
+  plural: string
+}
+export type ActivityCollectionMap = Record<string, ActivityCollectionInfo>
+
+export interface SystemActivityResponse {
+  entries: AuditLogEntryDto[]
+  meta: { total: number; page: number; pageSize: number; totalPages: number }
+  /** Acting-user id → display label. Absent ids (system rows, deleted users) render a tombstone. */
+  actors: ActorLabelMap
+  /** Collection id → display info. Absent ids name a removed collection. */
+  collections: ActivityCollectionMap
+}
+
+/**
+ * The system-wide activity feed: the union of the version stream (content
+ * saves) and the audit log (status / path / locale changes, deletions, and
+ * future admin-realm events). Unlike the per-document audit fn, this is NOT
+ * routed through `CollectionHandle` — it is cross-collection and includes
+ * admin-realm rows with no `document_id`, so it reads the adapter's audit
+ * queries directly and is gated system-wide by `admin.activity.read` rather
+ * than by any document's own read gate.
+ */
+export const getSystemActivityLog = createServerFn({ method: 'GET' })
+  .validator((input: SystemActivitySearchParams) => input ?? {})
+  .handler(async ({ data }): Promise<SystemActivityResponse> => {
+    const context = await getAdminRequestContext()
+    // System-wide gate — independent of any collection ability. An auditor
+    // role holds this without holding content read/write.
+    assertAdminActor(context, ADMIN_ACTIVITY_ABILITIES.read)
+
+    const queries = getServerConfig().db.queries
+    if (queries.audit == null) {
+      throw ERR_AUDIT_UNSUPPORTED({
+        message: 'the configured db adapter does not support audit-log reads (queries.audit)',
+      }).log(getLogger())
+    }
+
+    // The admin works in collection paths; the audit rows store the collection
+    // id. Resolve path → id here. An unknown path yields no id, so the filter
+    // simply matches nothing rather than erroring.
+    let collectionId: string | undefined
+    if (data.collection) {
+      const col = await queries.collections.getCollectionByPath(data.collection)
+      collectionId = col?.id
+      if (collectionId == null) {
+        return {
+          entries: [],
+          meta: { total: 0, page: 1, pageSize: 0, totalPages: 0 },
+          actors: {},
+          collections: {},
+        }
+      }
+    }
+
+    const result = await queries.audit.findAuditLog({
+      actorId: data.actorId,
+      collectionId,
+      action: data.action,
+      from: data.from ? new Date(data.from) : undefined,
+      to: data.to ? new Date(data.to) : undefined,
+      page: data.page,
+      page_size: data.page_size,
+    })
+
+    // Acting-user labels (admin realm), resolved here from each row's raw
+    // actorId — same helper the per-document audit view uses. System/tooling
+    // rows (NULL actorId) and deleted users are absent from the map; the UI
+    // renders the tombstone label.
+    const actors: ActorLabelMap = await resolveActorLabels(result.entries.map((e) => e.actorId))
+
+    // Collection display info, keyed by the raw collectionId carried on each
+    // row. Resolved once from the current collection set; a row whose
+    // collection was since removed is simply absent (the log outlives it).
+    const collections: ActivityCollectionMap = {}
+    const collectionIds = new Set(
+      result.entries.map((e) => e.collectionId).filter((id): id is string => id != null)
+    )
+    if (collectionIds.size > 0) {
+      const all = await queries.collections.getAllCollections()
+      for (const c of all) {
+        if (collectionIds.has(c.id)) {
+          collections[c.id] = { path: c.path, singular: c.singular, plural: c.plural }
+        }
+      }
+    }
+
+    const entries: AuditLogEntryDto[] = result.entries.map((e) => ({
+      id: e.id,
+      documentId: e.documentId,
+      collectionId: e.collectionId,
+      actorId: e.actorId,
+      actorRealm: e.actorRealm,
+      action: e.action,
+      field: e.field,
+      before: e.before as string | string[] | null,
+      after: e.after as string | string[] | null,
+      occurredAt: e.occurredAt instanceof Date ? e.occurredAt.toISOString() : String(e.occurredAt),
+    }))
+
+    return { entries, meta: result.meta, actors, collections }
+  })

package/src/server-fns/admin-activity/index.ts

@@ -0,0 +1,23 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+
+/**
+ * Admin-activity server fns (docs/AUDIT.md — Workstream 4) — the
+ * system-wide activity report. Reads the adapter's audit queries directly
+ * (cross-collection, includes admin-realm rows) behind the
+ * `admin.activity.read` gate, rather than routing through a per-document
+ * read like the collections audit fn.
+ */
+
+export {
+  type ActivityCollectionInfo,
+  type ActivityCollectionMap,
+  getSystemActivityLog,
+  type SystemActivityResponse,
+  type SystemActivitySearchParams,
+} from './get.js'

package/src/server-fns/admin-permissions/get-role-abilities.ts

@@ -17,7 +17,7 @@ import { getAdminRequestContext } from '../../auth/auth-context.js'
 import { bylineCore } from '../../integrations/byline-core.js'
 
 export const getRoleAbilities = createServerFn({ method: 'GET' })
-  .inputValidator((input: { id: string }) => input)
+  .validator((input: { id: string }) => input)
   .handler(async ({ data }): Promise<GetRoleAbilitiesResponse> => {
     const context = await getAdminRequestContext()
     return getRoleAbilitiesCommand(context, data, {

package/src/server-fns/admin-permissions/set-role-abilities.ts

@@ -22,7 +22,7 @@ export interface SetRoleAbilitiesInput {
 }
 
 export const setRoleAbilities = createServerFn({ method: 'POST' })
-  .inputValidator((input: SetRoleAbilitiesInput) => input)
+  .validator((input: SetRoleAbilitiesInput) => input)
   .handler(async ({ data }): Promise<SetRoleAbilitiesResponse> => {
     const context = await getAdminRequestContext()
     return setRoleAbilitiesCommand(context, data, {

package/src/server-fns/admin-permissions/who-has.ts

@@ -14,7 +14,7 @@ import { getAdminRequestContext } from '../../auth/auth-context.js'
 import { bylineCore } from '../../integrations/byline-core.js'
 
 export const whoHasAbility = createServerFn({ method: 'GET' })
-  .inputValidator((input: { ability: string }) => input)
+  .validator((input: { ability: string }) => input)
   .handler(async ({ data }): Promise<WhoHasAbilityResponse> => {
     const context = await getAdminRequestContext()
     return whoHasAbilityCommand(context, data, {

package/src/server-fns/admin-roles/create.ts

@@ -21,7 +21,7 @@ export interface CreateAdminRoleInput {
 }
 
 export const createAdminRole = createServerFn({ method: 'POST' })
-  .inputValidator((input: CreateAdminRoleInput) => input)
+  .validator((input: CreateAdminRoleInput) => input)
   .handler(async ({ data }): Promise<AdminRoleResponse> => {
     const context = await getAdminRequestContext()
     return createAdminRoleCommand(context, data, { store: bylineCore().adminStore! })