@byline/host-tanstack-start 4.16.0 → 4.17.0

package/src/routes/index.ts

@@ -51,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/collections/actors.ts

@@ -6,55 +6,4 @@
  * Copyright (c) Infonomic Company Limited
  */
 
-/**
- * Audit actor-label resolution (docs/07-auth-and-security/02-auditability.md — Workstream 1).
- *
- * Shaped documents carry only the raw `createdBy` uuid; turning ids into
- * display labels is an **admin-realm** concern, so it happens here — in
- * the admin server-fn layer, which already holds the admin actor and the
- * `AdminStore` — never as a JOIN inside the document storage adapter
- * (which must stay ignorant of admin-realm tables for the future
- * `UserAuth` writer realm).
- *
- * Responses attach the result as an `actors` map alongside the page of
- * documents; the UI joins by id. Ids with no matching admin-user row
- * (deleted users) are absent from the map — consumers render a tombstone
- * label.
- */
-
-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. Accepts the raw
- * `createdBy` values straight off a page of shaped documents — nullish
- * and duplicate entries are tolerated and deduplicated. Returns `{}`
- * when there is nothing to resolve or no admin store is configured.
- */
-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
-}
+export { type ActorLabelMap, resolveActorLabels } from '../actors.js'

package/src/server-fns/collections/get.ts

@@ -11,19 +11,16 @@ import { createServerFn } from '@tanstack/react-start'
 import { getAdminBylineClient, getAdminRequestContext } from '@byline/client/server'
 import {
   BylineError,
-  buildRelationSummaryPopulateMap,
-  collectionAbilityKey,
+  documentAbilityKey,
   ERR_NOT_FOUND,
   ErrorCodes,
-  getCollectionAdminConfig,
-  getCollectionDefinition,
   getCollectionSchemasForPath,
   getLogger,
   getServerConfig,
-  type PopulateSpec,
 } from '@byline/core'
 
 import { ensureCollection } from '../../integrations/api-utils.js'
+import { resolveAdminDocumentRead } from '../admin-document-presentation.js'
 import { serialise } from './utils'
 
 // ---------------------------------------------------------------------------
@@ -54,49 +51,14 @@ const getDocumentFn = createServerFn({ method: 'GET' })
     const client = getAdminBylineClient()
     const handle = client.collection(path)
 
-    // Determine populate strategy. The admin API-preview path passes an
-    // explicit `depth > 0` and uses `'*'` to walk every relation with the
-    // full document projection — useful for the debug/preview UI but
-    // wasteful elsewhere. The admin edit loader sets `populateRelations`
-    // to auto-build a depth-1 projection from the schema's relation
-    // fields, so each target gets just its picker columns + useAsTitle
-    // and relation-summary tiles render on first paint without per-tile
-    // fetches.
-    const populateRequested = typeof depth === 'number' && depth > 0
-    const autoRelationsActive = !populateRequested && populateRelations === true
-
-    let populate: PopulateSpec | undefined
-    let resolvedDepth: number | undefined
-    if (populateRequested) {
-      populate = '*'
-      resolvedDepth = depth
-    } else if (autoRelationsActive) {
-      const populateMap = buildRelationSummaryPopulateMap(
-        config.definition.fields,
-        (targetPath) => ({
-          def: getCollectionDefinition(targetPath),
-          admin: getCollectionAdminConfig(targetPath),
-        })
-      )
-      if (Object.keys(populateMap).length > 0) {
-        populate = populateMap
-        resolvedDepth = 1
-      }
-    }
+    const { options: readOptions, populatedTree } = resolveAdminDocumentRead(config.definition, {
+      locale,
+      depth,
+      populateRelations,
+    })
 
     const document = await handle.findById(id, {
-      locale: locale ?? 'en',
-      populate,
-      depth: resolvedDepth,
-      status: 'any',
-      // Admin edit path: show the RAW per-locale values — untranslated localized
-      // fields stay empty (the signal to use "Copy to Locale"), never falling
-      // back to the default locale. Overrides the client's `'fallback'` default.
-      onMissingLocale: 'empty',
-      // Admin edit path: tolerate schema-mismatch warnings rather than
-      // hard-failing the load. Warnings (if any) come back on the document
-      // as `_restoreWarnings` and the edit form surfaces them via an Alert.
-      lenient: true,
+      ...readOptions,
     })
 
     if (!document) {
@@ -114,7 +76,6 @@ const getDocumentFn = createServerFn({ method: 'GET' })
     //     don't match the raw relation-ref shape the schema expects —
     //     applies equally to the depth-based preview path and the
     //     admin-edit relation-summary path)
-    const populatedTree = populateRequested || autoRelationsActive
     const parsed =
       locale === 'all' || populatedTree
         ? (serialised as Record<string, any>)
@@ -177,8 +138,8 @@ const getDocumentFn = createServerFn({ method: 'GET' })
     if (scheduledPublicationEnabled) {
       const actor = (await getAdminRequestContext()).actor
       canSchedulePublication =
-        actor?.hasAbility(collectionAbilityKey(path, 'changeStatus')) === true &&
-        actor.hasAbility(collectionAbilityKey(path, 'publish'))
+        actor?.hasAbility(documentAbilityKey(config.definition, 'changeStatus')) === true &&
+        actor.hasAbility(documentAbilityKey(config.definition, 'publish'))
       if (canSchedulePublication) {
         scheduledPublish = await handle.getScheduledPublish(id)
       }

package/src/server-fns/collections/reorder.ts

@@ -66,7 +66,7 @@ export const reorderCollectionDocument = createServerFn({ method: 'POST' })
     }
 
     const requestContext = await getAdminRequestContext()
-    assertActorCanPerform(requestContext, path, 'update')
+    assertActorCanPerform(requestContext, config.definition, 'update')
 
     const serverConfig = getServerConfig()
     const collectionId = config.collection.id

package/src/server-fns/collections/scheduled-publication.ts

@@ -15,6 +15,7 @@ import {
   type DocumentPublishScheduleState,
   ERR_NOT_FOUND,
   ERR_VALIDATION,
+  isSingleton,
   type RecurringTaskHealth,
 } from '@byline/core'
 import { listDocumentPublishSchedules } from '@byline/core/services'
@@ -247,7 +248,12 @@ export const listScheduledPublications = createServerFn({ method: 'GET' })
         return {
           ...serializeSchedule(schedule),
           collectionPath: definition?.path ?? schedule.collectionId,
-          collectionLabel: definition?.labels.plural ?? definition?.path ?? schedule.collectionId,
+          collectionLabel:
+            definition == null
+              ? schedule.collectionId
+              : isSingleton(definition)
+                ? definition.label
+                : definition.labels.plural,
           documentPath,
           lastAuthorizedByName:
             schedule.lastAuthorizedBy == null

package/src/server-fns/collections/upload-singleton.test.node.ts

@@ -0,0 +1,164 @@
+/**
+ * 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 { AdminAuth, createRequestContext } from '@byline/auth'
+import {
+  defineServerConfig,
+  defineSingleton,
+  type IDbAdapter,
+  type IStorageProvider,
+} from '@byline/core'
+import { defineLogger } from '@byline/core/logger'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  getAdminRequestContext: vi.fn(),
+  getCollectionRecord: vi.fn(),
+}))
+
+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('@byline/client/server', () => ({
+  getAdminRequestContext: mocks.getAdminRequestContext,
+}))
+
+vi.mock('@byline/core/image', () => ({
+  extractImageMeta: vi.fn(async () => ({ width: null, height: null, format: null })),
+  generateImageVariants: vi.fn(async () => []),
+  isBypassMimeType: vi.fn(() => false),
+}))
+
+vi.mock('../../integrations/byline-core.js', () => ({
+  bylineCore: () => ({ getCollectionRecord: mocks.getCollectionRecord }),
+}))
+
+import { ensureCollection, ensureDocumentResource } from '../../integrations/api-utils.js'
+import { uploadField } from './upload.js'
+
+const SERVER_CONFIG = Symbol.for('__byline_server_config__')
+const BYLINE_LOGGER = Symbol.for('__byline_logger__')
+const previousServer = (globalThis as Record<PropertyKey, unknown>)[SERVER_CONFIG]
+const previousLogger = (globalThis as Record<PropertyKey, unknown>)[BYLINE_LOGGER]
+
+const singleton = defineSingleton({
+  path: 'site-settings',
+  label: 'Site settings',
+  fields: [
+    {
+      name: 'hero',
+      label: 'Hero image',
+      type: 'file',
+      upload: { mimeTypes: ['text/plain'], requireSavedDocument: true },
+    },
+  ],
+})
+
+const storageUpload = vi.fn(async () => ({
+  storageProvider: 'test',
+  storagePath: 'site-settings/hero.txt',
+  storageUrl: '/uploads/site-settings/hero.txt',
+}))
+
+const storage: IStorageProvider = {
+  providerName: 'test',
+  upload: storageUpload,
+  delete: vi.fn(async () => {}),
+  getUrl: (path) => `/uploads/${path}`,
+}
+
+beforeAll(() => {
+  const silent = () => {}
+  defineLogger({
+    log: silent,
+    fatal: silent,
+    error: silent,
+    warn: silent,
+    info: silent,
+    debug: silent,
+    trace: silent,
+    silent,
+  })
+  mocks.getCollectionRecord.mockReturnValue({
+    collectionId: 'collection-settings',
+    version: 1,
+    schemaHash: 'singleton-hash',
+  })
+  mocks.getAdminRequestContext.mockResolvedValue(
+    createRequestContext({
+      actor: new AdminAuth({
+        id: 'settings-editor',
+        abilities: ['singletons.site-settings.update'],
+      }),
+    })
+  )
+  defineServerConfig({
+    collections: [singleton],
+    db: {} as IDbAdapter,
+    storage,
+    i18n: {
+      admin: { defaultLocale: 'en', locales: ['en'] },
+      content: { defaultLocale: 'en', locales: ['en'] },
+    },
+  })
+})
+
+afterAll(() => {
+  const globals = globalThis as Record<PropertyKey, unknown>
+  if (previousServer === undefined) delete globals[SERVER_CONFIG]
+  else globals[SERVER_CONFIG] = previousServer
+  if (previousLogger === undefined) delete globals[BYLINE_LOGGER]
+  else globals[BYLINE_LOGGER] = previousLogger
+})
+
+describe('singleton field upload host transport', () => {
+  it('keeps collection routes closed while resolving the shared upload resource', async () => {
+    await expect(ensureCollection('site-settings')).resolves.toBeNull()
+    await expect(ensureDocumentResource('site-settings')).resolves.toMatchObject({
+      definition: { singleton: true, path: 'site-settings' },
+      collection: { id: 'collection-settings', version: 1 },
+    })
+  })
+
+  it('stores a singleton field without taking the collection create branch', async () => {
+    const formData = new FormData()
+    formData.set('field', 'hero')
+    formData.set('file', new File(['hero'], 'Hero.txt', { type: 'text/plain' }))
+
+    const result = await uploadField('site-settings', formData, false)
+
+    expect(mocks.getCollectionRecord).toHaveBeenCalledWith('site-settings')
+    expect(storageUpload).toHaveBeenCalledWith(
+      Buffer.from('hero'),
+      expect.objectContaining({
+        collection: 'site-settings',
+        filename: 'hero.txt',
+        mimeType: 'text/plain',
+      })
+    )
+    expect(result.documentId).toBeUndefined()
+    expect(result.storedFile).toMatchObject({
+      filename: 'hero.txt',
+      storageProvider: 'test',
+      storagePath: 'site-settings/hero.txt',
+    })
+  })
+})

package/src/server-fns/collections/upload.ts

@@ -13,7 +13,7 @@ import { extractImageMeta, generateImageVariants, isBypassMimeType } from '@byli
 import { getLogger, withLogContext } from '@byline/core/logger'
 import { uploadField as coreUploadField } from '@byline/core/services'
 
-import { ensureCollection } from '../../integrations/api-utils.js'
+import { ensureDocumentResource } from '../../integrations/api-utils.js'
 
 /**
  * Result of an upload through the host transport. The legacy top-level
@@ -156,11 +156,15 @@ export const uploadCollectionField = createServerFn({ method: 'POST' })
     return withLogContext(
       { domain: 'api', module: 'upload', function: 'uploadCollectionField' },
       async () => {
-        const config = await ensureCollection(collectionPath)
+        // Upload is the one field transport shared by both document-resource
+        // kinds. The core service selects the kind-aware ability and rejects
+        // singleton document creation before hooks or storage; the admin form
+        // always requests the field-only branch (`createDocument=false`).
+        const config = await ensureDocumentResource(collectionPath)
         if (config == null) {
           throw ERR_NOT_FOUND(
             {
-              message: 'Collection not found.',
+              message: 'Document resource not found.',
               details: { collectionPath },
             },
             uploadCollectionField

package/src/server-fns/collections/utils.ts

@@ -6,12 +6,4 @@
  * Copyright (c) Infonomic Company Limited
  */
 
-/**
- * Deep-serialise a value through JSON to convert Date objects to ISO strings.
- * TanStack Start server functions pass return values directly during SSR
- * (no automatic JSON round-trip), so Date instances from the DB driver would
- * fail downstream Zod z.string() checks without this explicit step.
- */
-export function serialise<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value))
-}
+export { serialise } from '../serialise.js'

package/src/server-fns/serialise.ts

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+
+/**
+ * Deep-serialise a value through JSON to convert Date objects to ISO strings.
+ * TanStack Start server functions pass return values directly during SSR
+ * (no automatic JSON round-trip), so Date instances from the DB driver would
+ * fail downstream string checks without this explicit step.
+ */
+export function serialise<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value))
+}

package/src/server-fns/singleton-document-read.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { getAdminBylineClient } from '@byline/client/server'
+import { getCollectionDefinition } from '@byline/core'
+
+import { resolveAdminDocumentRead } from './admin-document-presentation.js'
+import { serialise } from './serialise.js'
+
+export interface SingletonDocumentReadInput {
+  singleton: string
+  locale?: string
+  depth?: number
+  populateRelations?: boolean
+}
+
+/**
+ * Read the singleton document with the presentation controls shared by the
+ * editor route and the public server function. Route-only lifecycle metadata
+ * is deliberately composed one layer up, where host database and actor
+ * context are available without widening the singleton transport contract.
+ */
+export async function readSingletonDocument(data: SingletonDocumentReadInput) {
+  const handle = getAdminBylineClient().singleton(data.singleton)
+  const { options } = resolveAdminDocumentRead(getCollectionDefinition(data.singleton), data)
+  return serialise(await handle.get(options))
+}

package/src/server-fns/singletons/cancel-scheduled-publish.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { getAdminBylineClient } from '@byline/client/server'
+
+import { serialise } from '../serialise.js'
+
+export const cancelSingletonScheduledPublish = createServerFn({ method: 'POST' })
+  .validator((input: { singleton: string }) => input)
+  .handler(async ({ data }) =>
+    serialise(await getAdminBylineClient().singleton(data.singleton).cancelScheduledPublish())
+  )

package/src/server-fns/singletons/change-status.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { getAdminBylineClient } from '@byline/client/server'
+
+import { serialise } from '../serialise.js'
+
+export const changeSingletonStatus = createServerFn({ method: 'POST' })
+  .validator((input: { singleton: string; status: string }) => input)
+  .handler(async ({ data }) =>
+    serialise(await getAdminBylineClient().singleton(data.singleton).changeStatus(data.status))
+  )

package/src/server-fns/singletons/confirm-scheduled-publish.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
+ */
+
+import { createServerFn } from '@tanstack/react-start'
+
+import { getAdminBylineClient } from '@byline/client/server'
+
+import { serialise } from '../serialise.js'
+
+export const confirmSingletonScheduledPublish = createServerFn({ method: 'POST' })
+  .validator((input: { singleton: string; expectedVersionId: string }) => input)
+  .handler(async ({ data }) =>
+    serialise(
+      await getAdminBylineClient()
+        .singleton(data.singleton)
+        .confirmScheduledPublish({ expectedVersionId: data.expectedVersionId })
+    )
+  )

package/src/server-fns/singletons/copy-to-locale.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { getAdminBylineClient } from '@byline/client/server'
+
+import { serialise } from '../serialise.js'
+
+export const copySingletonToLocale = createServerFn({ method: 'POST' })
+  .validator(
+    (input: {
+      singleton: string
+      sourceLocale: string
+      targetLocale: string
+      overwrite?: boolean
+    }) => input
+  )
+  .handler(async ({ data }) =>
+    serialise(
+      await getAdminBylineClient().singleton(data.singleton).copyToLocale({
+        sourceLocale: data.sourceLocale,
+        targetLocale: data.targetLocale,
+        overwrite: data.overwrite,
+      })
+    )
+  )