@byline/host-tanstack-start 4.15.0 → 4.17.0

package/src/routes/create-singleton-route.test.node.ts

@@ -0,0 +1,172 @@
+/**
+ * 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 { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  definition: {
+    singleton: true,
+    path: 'site-settings',
+    label: 'Site settings',
+    fields: [{ name: 'title', type: 'text', defaultValue: 'Default title' }],
+  },
+  read: vi.fn(),
+  buildInitialData: vi.fn(),
+  getPublishedVersion: vi.fn(),
+  getRequestContext: vi.fn(),
+  getScheduledPublish: vi.fn(),
+  getCollectionRecord: vi.fn(),
+  scheduledPublicationEnabled: true,
+}))
+
+vi.mock('@tanstack/react-start', () => ({
+  createServerFn: () => {
+    let validate = (input: unknown) => input
+    const chain = {
+      validator(validator: (input: unknown) => unknown) {
+        validate = validator
+        return chain
+      },
+      handler(handler: (options: { data: any }) => Promise<unknown>) {
+        return async (options: { data: unknown }) => handler({ data: validate(options.data) })
+      },
+    }
+    return chain
+  },
+}))
+
+vi.mock('@tanstack/react-router', () => ({
+  createFileRoute: () => (options: Record<string, unknown>) => ({ options }),
+  notFound: () => new Error('not found'),
+}))
+
+vi.mock('@byline/client/server', () => ({
+  getAdminBylineClient: () => ({
+    singleton: () => ({ getScheduledPublish: mocks.getScheduledPublish }),
+  }),
+  getAdminRequestContext: mocks.getRequestContext,
+}))
+
+vi.mock('@byline/core', () => ({
+  buildInitialDataFromFields: mocks.buildInitialData,
+  documentAbilityKey: (_definition: unknown, verb: string) => `singletons.site-settings.${verb}`,
+  getCollectionDefinition: (path: string) =>
+    path === mocks.definition.path ? mocks.definition : null,
+  isSingleton: (definition: { singleton?: boolean }) => definition.singleton === true,
+  getServerConfig: () => ({
+    i18n: { content: { defaultLocale: 'en' } },
+    scheduledPublication: { enabled: mocks.scheduledPublicationEnabled },
+    db: { queries: { documents: { getPublishedVersion: mocks.getPublishedVersion } } },
+  }),
+  getSingletonAdminConfig: () => null,
+}))
+
+vi.mock('../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js', () => ({
+  BreadcrumbsClient: () => null,
+}))
+vi.mock('../admin-shell/singletons/view.js', () => ({ SingletonView: () => null }))
+vi.mock('../integrations/byline-core.js', () => ({
+  bylineCore: () => ({ getCollectionRecord: mocks.getCollectionRecord }),
+}))
+vi.mock('../server-fns/singleton-document-read.js', () => ({
+  readSingletonDocument: mocks.read,
+}))
+vi.mock('../server-fns/serialise.js', () => ({ serialise: (value: unknown) => value }))
+vi.mock('@byline/i18n/react', () => ({ useTranslation: () => ({ t: (key: string) => key }) }))
+vi.mock('./admin-path.js', () => ({ getAdminRoutePath: () => '/admin' }))
+vi.mock('./get-content-locale-route-config.js', () => ({
+  getContentLocaleRouteConfig: () => ({ contentLocales: [], defaultContentLocale: 'en' }),
+}))
+
+import { getSingletonRouteDocument } from './create-singleton-route.js'
+
+type ServerFunction = (options: { data: { singleton: string; locale?: string } }) => Promise<any>
+
+const load = (locale?: string) =>
+  (getSingletonRouteDocument as ServerFunction)({
+    data: { singleton: 'site-settings', locale },
+  })
+
+describe('singleton editor route loader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.scheduledPublicationEnabled = true
+    mocks.buildInitialData.mockResolvedValue({ title: 'Default title' })
+    mocks.getCollectionRecord.mockReturnValue({ collectionId: 'collection-settings' })
+    mocks.getRequestContext.mockResolvedValue({
+      actor: {
+        hasAbility: (ability: string) =>
+          ability === 'singletons.site-settings.changeStatus' ||
+          ability === 'singletons.site-settings.publish',
+      },
+    })
+  })
+
+  it('resolves schema defaults without inventing a document for an empty slot', async () => {
+    mocks.read.mockResolvedValue(null)
+
+    await expect(load('fr')).resolves.toEqual({
+      document: null,
+      initialData: { title: 'Default title' },
+    })
+    expect(mocks.read).toHaveBeenCalledWith({
+      singleton: 'site-settings',
+      locale: 'fr',
+      populateRelations: true,
+    })
+    expect(mocks.buildInitialData).toHaveBeenCalledWith(mocks.definition.fields, { locale: 'fr' })
+    expect(mocks.getCollectionRecord).not.toHaveBeenCalled()
+    expect(mocks.getRequestContext).not.toHaveBeenCalled()
+  })
+
+  it('attaches publication and schedule metadata to a mapped document server-side', async () => {
+    mocks.read.mockResolvedValue({
+      id: 'document-settings',
+      versionId: 'version-current',
+      status: 'draft',
+      fields: { title: 'Loaded' },
+    })
+    mocks.getPublishedVersion.mockResolvedValue({
+      document_id: 'document-settings',
+      document_version_id: 'version-published',
+      status: 'published',
+      created_at: '2026-08-25T00:00:00.000Z',
+      updated_at: '2026-08-25T01:00:00.000Z',
+    })
+    mocks.getScheduledPublish.mockResolvedValue({
+      state: 'armed',
+      publishAt: '2026-09-01T00:00:00.000Z',
+      targetVersionId: 'version-current',
+    })
+
+    const result = await load()
+
+    expect(result.initialData).toBeUndefined()
+    expect(result.document).toMatchObject({
+      id: 'document-settings',
+      _publishedVersion: {
+        id: 'document-settings',
+        versionId: 'version-published',
+        status: 'published',
+      },
+      _scheduledPublicationEnabled: true,
+      _canSchedulePublication: true,
+      _scheduledPublish: {
+        state: 'armed',
+        targetVersionId: 'version-current',
+      },
+      scheduledPublishAt: '2026-09-01T00:00:00.000Z',
+      scheduledPublishVersionId: 'version-current',
+    })
+    expect(mocks.getPublishedVersion).toHaveBeenCalledWith({
+      collection_id: 'collection-settings',
+      document_id: 'document-settings',
+    })
+    expect(mocks.getScheduledPublish).toHaveBeenCalledTimes(1)
+  })
+})

package/src/routes/create-singleton-route.tsx

@@ -0,0 +1,176 @@
+/**
+ * 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, notFound } from '@tanstack/react-router'
+import { createServerFn } from '@tanstack/react-start'
+
+import type { DocumentPublishScheduleInfo } from '@byline/client'
+import { getAdminBylineClient, getAdminRequestContext } from '@byline/client/server'
+import {
+  buildInitialDataFromFields,
+  documentAbilityKey,
+  getServerConfig,
+  getSingletonAdminConfig,
+} from '@byline/core'
+import { useTranslation } from '@byline/i18n/react'
+import { z } from 'zod'
+
+import { BreadcrumbsClient } from '../admin-shell/chrome/breadcrumbs/breadcrumbs-client.js'
+import { SingletonView } from '../admin-shell/singletons/view.js'
+import { bylineCore } from '../integrations/byline-core.js'
+import { serialise } from '../server-fns/serialise.js'
+import { readSingletonDocument } from '../server-fns/singleton-document-read.js'
+import { getAdminRoutePath } from './admin-path.js'
+import { getContentLocaleRouteConfig } from './get-content-locale-route-config.js'
+import { getSingletonDefinition } from './get-singleton-definition.js'
+
+const searchSchema = z.object({ locale: z.string().optional() })
+
+/**
+ * Load the mapped singleton document and attach the admin-only lifecycle
+ * metadata consumed by the editor. Keeping this composition in the route
+ * layer leaves ordinary singleton reads free of publication timing and actor
+ * capability details.
+ */
+export const getSingletonRouteDocument = createServerFn({ method: 'GET' })
+  .validator((input: { singleton: string; locale?: string }) => input)
+  .handler(async ({ data }) => {
+    const definition = getSingletonDefinition(data.singleton)
+    if (definition == null) return null
+
+    const document = await readSingletonDocument({
+      singleton: data.singleton,
+      locale: data.locale,
+      populateRelations: true,
+    })
+    if (document == null) {
+      return {
+        document: null,
+        initialData: serialise(
+          await buildInitialDataFromFields(definition.fields, {
+            locale: data.locale ?? getServerConfig().i18n.content.defaultLocale,
+          })
+        ),
+      }
+    }
+
+    const config = getServerConfig()
+    const record = bylineCore().getCollectionRecord(data.singleton)
+
+    // A current draft may coexist with an older published version. That fact
+    // is editorial metadata, so it is intentionally attached only here rather
+    // than to every singleton read.
+    let publishedVersion: Record<string, any> | null = null
+    if ((document as Record<string, unknown>).status !== 'published') {
+      const published = await config.db.queries.documents.getPublishedVersion({
+        collection_id: record.collectionId,
+        document_id: String((document as Record<string, unknown>).id),
+      })
+      publishedVersion = published
+        ? serialise({
+            id: published.document_id,
+            versionId: published.document_version_id,
+            status: published.status,
+            createdAt: published.created_at,
+            updatedAt: published.updated_at,
+          })
+        : null
+    }
+
+    // Scheduling metadata is revealed only when the feature is enabled and
+    // the authenticated actor holds both abilities needed to arm a publish.
+    const scheduledPublicationEnabled = config.scheduledPublication?.enabled === true
+    let canSchedulePublication = false
+    let scheduledPublish: DocumentPublishScheduleInfo | null = null
+    if (scheduledPublicationEnabled) {
+      const actor = (await getAdminRequestContext()).actor
+      canSchedulePublication =
+        actor?.hasAbility(documentAbilityKey(definition, 'changeStatus')) === true &&
+        actor.hasAbility(documentAbilityKey(definition, 'publish'))
+      if (canSchedulePublication) {
+        scheduledPublish = await getAdminBylineClient()
+          .singleton(data.singleton)
+          .getScheduledPublish()
+      }
+    }
+    const serializedSchedule = scheduledPublish == null ? null : serialise(scheduledPublish)
+
+    return {
+      document: {
+        ...(document as Record<string, unknown>),
+        _publishedVersion: publishedVersion,
+        _scheduledPublicationEnabled: scheduledPublicationEnabled,
+        _canSchedulePublication: canSchedulePublication,
+        _scheduledPublish: serializedSchedule,
+        ...(serializedSchedule == null
+          ? {}
+          : {
+              scheduledPublishAt: serializedSchedule.publishAt,
+              scheduledPublishVersionId: serializedSchedule.targetVersionId,
+            }),
+      },
+      initialData: undefined,
+    }
+  })
+
+export function createSingletonRoute(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: z.infer<typeof searchSchema> }) => ({
+      locale: search.locale,
+    }),
+    loader: async ({
+      params,
+      deps,
+    }: {
+      params: { singleton: string }
+      deps: { locale?: string }
+    }) => {
+      if (getSingletonDefinition(params.singleton) == null) throw notFound()
+      return getSingletonRouteDocument({
+        data: { singleton: params.singleton, locale: deps.locale },
+      })
+    },
+    staleTime: 0,
+    gcTime: 0,
+    shouldReload: true,
+    component: function SingletonRouteComponent() {
+      const routeState = Route.useLoaderData()
+      const { singleton } = Route.useParams() as { singleton: string }
+      const { locale } = Route.useSearch() as z.infer<typeof searchSchema>
+      const definition = getSingletonDefinition(singleton)
+      if (definition == null) throw notFound()
+
+      const { t } = useTranslation('byline-admin')
+      const { contentLocales, defaultContentLocale } = getContentLocaleRouteConfig()
+
+      return (
+        <>
+          <BreadcrumbsClient
+            breadcrumbs={[
+              { label: t('chrome.menu.dashboard'), href: getAdminRoutePath() },
+              { label: definition.label, href: getAdminRoutePath('singletons', singleton) },
+            ]}
+          />
+          <SingletonView
+            singletonDefinition={definition}
+            adminConfig={getSingletonAdminConfig(singleton) ?? undefined}
+            document={routeState.document}
+            initialData={routeState.initialData}
+            locale={locale}
+            contentLocales={contentLocales}
+            defaultContentLocale={defaultContentLocale}
+          />
+        </>
+      )
+    },
+  })
+
+  return Route
+}

package/src/routes/get-multi-collection-definition.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 type { MultiCollectionDefinition } from '@byline/core'
+import { getCollectionDefinition, isSingleton } from '@byline/core'
+
+/** Resolve only the resource kind supported by the collection route family. */
+export function getMultiCollectionDefinition(path: string): MultiCollectionDefinition | null {
+  const definition = getCollectionDefinition(path)
+  return definition != null && !isSingleton(definition) ? definition : null
+}

package/src/routes/get-singleton-definition.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 type { SingletonDefinition } from '@byline/core'
+import { getCollectionDefinition, isSingleton } from '@byline/core'
+
+/** Resolve only the resource kind supported by the singleton route family. */
+export function getSingletonDefinition(path: string): SingletonDefinition | null {
+  const definition = getCollectionDefinition(path)
+  return definition != null && isSingleton(definition) ? definition : null
+}

package/src/routes/index.ts

@@ -33,6 +33,7 @@ export { getSignInRoutePath } from './sign-in-path.js'
 
 export { createAdminAccountRoute } from './create-admin-account-route.js'
 export { createAdminActivityRoute } from './create-admin-activity-route.js'
+export { createAdminAnalyticsRoute } from './create-admin-analytics-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'
@@ -50,3 +51,5 @@ export {
   type CreateSignInRouteOptions,
   createSignInRoute,
 } from './create-sign-in-route.js'
+export { createSingletonHistoryRoute } from './create-singleton-history-route.js'
+export { createSingletonRoute } from './create-singleton-route.js'

package/src/server-fns/actors.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 type { AdminUserRow } from '@byline/admin/admin-users'
+
+import { bylineCore } from '../integrations/byline-core.js'
+
+export type ActorLabelMap = Record<string, { label: string }>
+
+/** Display label: full name → username → email. */
+function labelFor(row: AdminUserRow): string {
+  const name = [row.given_name, row.family_name].filter(Boolean).join(' ')
+  return name || row.username || row.email
+}
+
+/**
+ * Batch-resolve admin-user ids to display labels. The admin server-fn layer
+ * owns this presentation concern so both collection and singleton history
+ * can share it without teaching document storage about admin-realm tables.
+ */
+export async function resolveActorLabels(
+  ids: Iterable<string | null | undefined>
+): Promise<ActorLabelMap> {
+  const unique = [
+    ...new Set([...ids].filter((id): id is string => typeof id === 'string' && id.length > 0)),
+  ]
+  if (unique.length === 0) return {}
+
+  const store = bylineCore().adminStore
+  if (store == null) return {}
+
+  const rows = await store.adminUsers.getByIds(unique)
+  const map: ActorLabelMap = {}
+  for (const row of rows) {
+    map[row.id] = { label: labelFor(row) }
+  }
+  return map
+}

package/src/server-fns/admin-document-presentation.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 {
+  buildRelationSummaryPopulateMap,
+  type CollectionDefinition,
+  getCollectionAdminConfig,
+  getCollectionDefinition,
+  type PopulateSpec,
+} from '@byline/core'
+
+export interface AdminDocumentReadInput {
+  locale?: string
+  depth?: number
+  populateRelations?: boolean
+}
+
+export interface AdminDocumentReadOptions {
+  locale: string
+  populate?: PopulateSpec
+  depth?: number
+  status: 'any'
+  onMissingLocale: 'empty'
+  lenient: true
+}
+
+/**
+ * Resolve the shared read controls used by collection and singleton editors.
+ * Explicit depth is the API-preview mode; otherwise relation-summary mode
+ * projects only each target's picker/title fields for first-paint tiles.
+ */
+export function resolveAdminDocumentRead(
+  definition: CollectionDefinition | null,
+  input: AdminDocumentReadInput
+): { options: AdminDocumentReadOptions; populatedTree: boolean } {
+  const populateRequested = typeof input.depth === 'number' && input.depth > 0
+  const autoRelationsActive = !populateRequested && input.populateRelations === true
+
+  let populate: PopulateSpec | undefined
+  let depth: number | undefined
+  if (populateRequested) {
+    populate = '*'
+    depth = input.depth
+  } else if (autoRelationsActive && definition != null) {
+    const populateMap = buildRelationSummaryPopulateMap(definition.fields, (targetPath) => ({
+      def: getCollectionDefinition(targetPath),
+      admin: getCollectionAdminConfig(targetPath),
+    }))
+    if (Object.keys(populateMap).length > 0) {
+      populate = populateMap
+      depth = 1
+    }
+  }
+
+  return {
+    options: {
+      locale: input.locale ?? 'en',
+      populate,
+      depth,
+      status: 'any',
+      // Editors need the raw requested-locale values. Untranslated localized
+      // fields stay empty instead of falling back, which is the signal that
+      // enables the Copy to Locale workflow. Using `omit` would hide the whole
+      // resource and make a missing translation look like a missing slot.
+      onMissingLocale: 'empty',
+      // Older rows may no longer reconstruct exactly against the current
+      // schema. Keep the editor loadable and surface those mismatches through
+      // `_restoreWarnings`, which the form renders as an alert.
+      lenient: true,
+    },
+    populatedTree: populateRequested || autoRelationsActive,
+  }
+}

package/src/server-fns/analytics/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
+ */
+
+export {
+  type DeleteAnalyticsEventsInput,
+  deleteAnalyticsEvents,
+  rebuildAnalyticsDay,
+} from './maintenance.js'
+export {
+  type AnalyticsRuntimeState,
+  type AnalyticsTopInput,
+  getAnalyticsCountries,
+  getAnalyticsReferrers,
+  getAnalyticsReportCoverage,
+  getAnalyticsRuntime,
+  getAnalyticsSummary,
+  getAnalyticsTop,
+} from './queries.js'

package/src/server-fns/analytics/maintenance.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 { ANALYTICS_ABILITIES } from '@byline/admin/analytics'
+import { getAdminRequestContext } from '@byline/client/server'
+
+export interface DeleteAnalyticsEventsInput {
+  from: string
+  to: string
+  visitorHash?: string
+}
+
+export const deleteAnalyticsEvents = createServerFn({ method: 'POST' })
+  .validator((input: DeleteAnalyticsEventsInput) => input)
+  .handler(async ({ data }): Promise<{ deleted: number }> => {
+    await assertAnalyticsMaintenance()
+    const { getAnalytics } = await import('@byline/analytics')
+    const from = parseInstant(data.from, 'from')
+    const to = parseInstant(data.to, 'to')
+    const deleted = await getAnalytics().deleteEvents({
+      from,
+      to,
+      ...(data.visitorHash == null ? {} : { visitorHash: data.visitorHash }),
+    })
+    return { deleted }
+  })
+
+export const rebuildAnalyticsDay = createServerFn({ method: 'POST' })
+  .validator((input: { day: string }) => input)
+  .handler(async ({ data }): Promise<{ rebuilt: string }> => {
+    await assertAnalyticsMaintenance()
+    const { getAnalytics } = await import('@byline/analytics')
+    await getAnalytics().rebuildDay(data.day)
+    return { rebuilt: data.day }
+  })
+
+async function assertAnalyticsMaintenance(): Promise<void> {
+  const context = await getAdminRequestContext()
+  assertAdminActor(context, ANALYTICS_ABILITIES.maintain)
+}
+
+function parseInstant(value: string, label: string): Date {
+  const date = new Date(value)
+  if (Number.isNaN(date.valueOf())) throw new Error(`analytics ${label} must be an ISO instant`)
+  return date
+}

package/src/server-fns/analytics/queries.ts

@@ -0,0 +1,86 @@
+/**
+ * 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, requireAdminActor } from '@byline/admin'
+import { ANALYTICS_ABILITIES } from '@byline/admin/analytics'
+import type {
+  AnalyticsCountryTotal,
+  AnalyticsDateRange,
+  AnalyticsEventKind,
+  AnalyticsPathTotal,
+  AnalyticsRankedTotals,
+  AnalyticsReferrerTotal,
+  AnalyticsReportCoverage,
+  AnalyticsSummary,
+} from '@byline/analytics'
+import { getAdminRequestContext } from '@byline/client/server'
+
+export interface AnalyticsTopInput extends AnalyticsDateRange {
+  kind: AnalyticsEventKind
+  limit?: number
+}
+
+export interface AnalyticsRuntimeState {
+  enabled: boolean
+}
+
+export const getAnalyticsRuntime = createServerFn({ method: 'GET' }).handler(
+  async (): Promise<AnalyticsRuntimeState> => {
+    const context = await getAdminRequestContext()
+    requireAdminActor(context, 'reading analytics runtime state')
+    const { isAnalyticsRegistered } = await import('@byline/analytics')
+    return { enabled: isAnalyticsRegistered() }
+  }
+)
+
+export const getAnalyticsSummary = createServerFn({ method: 'GET' })
+  .validator((input: AnalyticsDateRange) => input)
+  .handler(async ({ data }): Promise<AnalyticsSummary> => {
+    await assertAnalyticsRead()
+    const { getAnalytics } = await import('@byline/analytics')
+    return getAnalytics().getSummary(data)
+  })
+
+export const getAnalyticsReportCoverage = createServerFn({ method: 'GET' }).handler(
+  async (): Promise<AnalyticsReportCoverage> => {
+    await assertAnalyticsRead()
+    const { getAnalytics } = await import('@byline/analytics')
+    return getAnalytics().getReportCoverage()
+  }
+)
+
+export const getAnalyticsTop = createServerFn({ method: 'GET' })
+  .validator((input: AnalyticsTopInput) => input)
+  .handler(async ({ data }): Promise<AnalyticsRankedTotals<AnalyticsPathTotal>> => {
+    await assertAnalyticsRead()
+    const { getAnalytics } = await import('@byline/analytics')
+    return getAnalytics().getTopPaths(data)
+  })
+
+export const getAnalyticsReferrers = createServerFn({ method: 'GET' })
+  .validator((input: AnalyticsDateRange & { limit?: number }) => input)
+  .handler(async ({ data }): Promise<AnalyticsRankedTotals<AnalyticsReferrerTotal>> => {
+    await assertAnalyticsRead()
+    const { getAnalytics } = await import('@byline/analytics')
+    return getAnalytics().getReferrers(data)
+  })
+
+export const getAnalyticsCountries = createServerFn({ method: 'GET' })
+  .validator((input: AnalyticsDateRange) => input)
+  .handler(async ({ data }): Promise<AnalyticsCountryTotal[]> => {
+    await assertAnalyticsRead()
+    const { getAnalytics } = await import('@byline/analytics')
+    return getAnalytics().getCountries(data)
+  })
+
+async function assertAnalyticsRead(): Promise<void> {
+  const context = await getAdminRequestContext()
+  assertAdminActor(context, ANALYTICS_ABILITIES.read)
+}