@actuate-media/cms-admin 0.16.1 → 0.18.0

package/src/__tests__/lib/page-editor-service-api.test.ts

@@ -0,0 +1,180 @@
+// @vitest-environment node
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+// Mock the network layer so we can assert on request shape (endpoint,
+// method, body) and drive responses. This is the class of bug — response
+// unwrapping and write-payload drift — these tests exist to catch.
+const cmsApi = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApi(...args),
+}))
+
+const { fetchPageForEditor, savePageDraft, publishPage, missingPageFields, emptyPage } =
+  await import('../../lib/page-editor-service.js')
+
+afterEach(() => {
+  cmsApi.mockReset()
+})
+
+function draft(id: string | null) {
+  return {
+    ...emptyPage(),
+    id,
+    title: 'About',
+    slug: 'about',
+    path: '/about',
+    seoTitle: 'About us',
+    seoDescription: 'Our story',
+    sections: [],
+  }
+}
+
+describe('fetchPageForEditor', () => {
+  it('maps a document row into an EditorPage', async () => {
+    cmsApi.mockResolvedValue({
+      data: {
+        id: 'p1',
+        title: 'About',
+        slug: 'about',
+        status: 'PUBLISHED',
+        publishedAt: '2026-01-02T00:00:00Z',
+        updatedAt: '2026-01-03T00:00:00Z',
+        data: { path: '/about', sections: [], metaTitle: 'T', metaDescription: 'D' },
+      },
+      status: 200,
+    })
+
+    const page = await fetchPageForEditor('p1')
+
+    expect(cmsApi).toHaveBeenCalledWith('/collections/pages/p1')
+    expect(page).toMatchObject({
+      id: 'p1',
+      title: 'About',
+      slug: 'about',
+      path: '/about',
+      status: 'PUBLISHED',
+      seoTitle: 'T',
+      seoDescription: 'D',
+    })
+  })
+
+  it('falls back to /slug for path when data.path is absent', async () => {
+    cmsApi.mockResolvedValue({
+      data: { id: 'p2', title: 'Home', slug: 'home', status: 'DRAFT', data: {} },
+      status: 200,
+    })
+    const page = await fetchPageForEditor('p2')
+    expect(page.path).toBe('/home')
+  })
+
+  it('throws the server error message on failure', async () => {
+    cmsApi.mockResolvedValue({ error: 'Document not found', status: 404 })
+    await expect(fetchPageForEditor('missing')).rejects.toThrow('Document not found')
+  })
+})
+
+describe('savePageDraft', () => {
+  it('PUTs sections + SEO without a status change for an existing page', async () => {
+    cmsApi.mockResolvedValue({
+      data: { id: 'p1', title: 'About', slug: 'about', status: 'DRAFT', data: { sections: [] } },
+      status: 200,
+    })
+
+    await savePageDraft(draft('p1'))
+
+    const [endpoint, opts] = cmsApi.mock.calls[0] as [string, RequestInit]
+    expect(endpoint).toBe('/collections/pages/p1')
+    expect(opts.method).toBe('PUT')
+    const body = JSON.parse(opts.body as string)
+    expect(body).toMatchObject({
+      title: 'About',
+      slug: 'about',
+      path: '/about',
+      sections: [],
+      metaTitle: 'About us',
+      metaDescription: 'Our story',
+    })
+    // Draft save must never flip status.
+    expect('status' in body).toBe(false)
+  })
+
+  it('creates (POST) a new page when there is no id', async () => {
+    cmsApi.mockResolvedValue({
+      data: { id: 'new1', title: 'About', slug: 'about', status: 'DRAFT', data: {} },
+      status: 201,
+    })
+
+    const saved = await savePageDraft(draft(null))
+
+    const [endpoint, opts] = cmsApi.mock.calls[0] as [string, RequestInit]
+    expect(endpoint).toBe('/collections/pages')
+    expect(opts.method).toBe('POST')
+    expect(saved.id).toBe('new1')
+  })
+
+  it('throws when the server rejects the write', async () => {
+    cmsApi.mockResolvedValue({ error: 'Forbidden', status: 403 })
+    await expect(savePageDraft(draft('p1'))).rejects.toThrow('Forbidden')
+  })
+})
+
+describe('publishPage', () => {
+  it('includes status: PUBLISHED in the payload', async () => {
+    cmsApi.mockResolvedValue({
+      data: { id: 'p1', title: 'About', slug: 'about', status: 'PUBLISHED', data: {} },
+      status: 200,
+    })
+
+    await publishPage(draft('p1'))
+
+    const [, opts] = cmsApi.mock.calls[0] as [string, RequestInit]
+    const body = JSON.parse(opts.body as string)
+    expect(body.status).toBe('PUBLISHED')
+  })
+})
+
+describe('missingPageFields', () => {
+  const fullFields = {
+    title: { type: 'text' },
+    slug: { type: 'slug' },
+    path: { type: 'text' },
+    sections: { type: 'json' },
+    metaTitle: { type: 'text' },
+    metaDescription: { type: 'text' },
+  }
+
+  it('returns [] when no config is provided', () => {
+    expect(missingPageFields(undefined)).toEqual([])
+    expect(missingPageFields(null)).toEqual([])
+    expect(missingPageFields({})).toEqual([])
+  })
+
+  it('returns [] when the pages collection declares every required field (record form)', () => {
+    const config = { collections: { pages: { slug: 'pages', fields: fullFields } } }
+    expect(missingPageFields(config)).toEqual([])
+  })
+
+  it('reports the missing required fields', () => {
+    const config = {
+      collections: {
+        pages: { slug: 'pages', fields: { title: { type: 'text' }, slug: { type: 'slug' } } },
+      },
+    }
+    expect(missingPageFields(config)).toEqual(['sections', 'path', 'metaTitle', 'metaDescription'])
+  })
+
+  it('supports the array form of field definitions', () => {
+    const config = {
+      collections: [
+        { slug: 'pages', fields: Object.entries(fullFields).map(([name, f]) => ({ name, ...f })) },
+      ],
+    }
+    expect(missingPageFields(config)).toEqual([])
+  })
+
+  it('flags a pages collection that omits sections (data-loss guard)', () => {
+    const { sections: _omitted, ...withoutSections } = fullFields
+    const config = { collections: { pages: { slug: 'pages', fields: withoutSections } } }
+    expect(missingPageFields(config)).toEqual(['sections'])
+  })
+})

package/src/__tests__/lib/pages-service-fetch.test.ts

@@ -0,0 +1,160 @@
+// @vitest-environment node
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const cmsApi = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApi(...args),
+}))
+
+const { fetchPages, fetchPagesDataset, bulkUpdatePages, bulkChangePageTags } =
+  await import('../../lib/pages-service.js')
+
+afterEach(() => {
+  cmsApi.mockReset()
+})
+
+function pageDoc(
+  id: string,
+  over: Record<string, unknown> = {},
+  data: Record<string, unknown> = {},
+) {
+  return {
+    id,
+    collection: 'pages',
+    title: id,
+    slug: id,
+    status: 'PUBLISHED',
+    createdById: 'u1',
+    updatedById: 'u1',
+    publishedAt: '2026-01-01T00:00:00Z',
+    scheduledAt: null,
+    createdAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:00:00Z',
+    data: { path: `/${id}`, ...data },
+    ...over,
+  }
+}
+
+// Route the three reads fetchPagesDataset performs (users, tags, pages).
+function routeReads(pages: unknown[], tags: unknown[] = []) {
+  cmsApi.mockImplementation((endpoint: string) => {
+    if (endpoint.startsWith('/users')) {
+      return Promise.resolve({
+        data: { users: [{ id: 'u1', name: 'Jane Doe', email: 'jane@example.com' }] },
+        status: 200,
+      })
+    }
+    if (endpoint.startsWith('/collections/page-tags')) {
+      return Promise.resolve({ data: { docs: tags, total: tags.length }, status: 200 })
+    }
+    if (endpoint.startsWith('/collections/pages')) {
+      return Promise.resolve({ data: { docs: pages, total: pages.length }, status: 200 })
+    }
+    return Promise.resolve({ data: null, status: 200 })
+  })
+}
+
+describe('fetchPagesDataset', () => {
+  it('returns every page plus tag counts derived from the full set', async () => {
+    routeReads(
+      [
+        pageDoc('p1', { status: 'DRAFT' }, { tags: ['a'] }),
+        pageDoc('p2', {}, { tags: ['a', 'b'] }),
+        pageDoc('p3'), // untagged
+      ],
+      [
+        { id: 't1', slug: 'a', title: 'Alpha', data: { color: 'green', sortOrder: 0 } },
+        { id: 't2', slug: 'b', title: 'Beta', data: { sortOrder: 1 } },
+      ],
+    )
+
+    const ds = await fetchPagesDataset()
+    expect(ds.pages).toHaveLength(3)
+    expect(ds.tags.find((t) => t.slug === 'a')?.pageCount).toBe(2)
+    expect(ds.tags.find((t) => t.slug === 'b')?.pageCount).toBe(1)
+    expect(ds.authors).toHaveLength(1)
+  })
+})
+
+describe('fetchPages counts', () => {
+  it('reports grandTotal as the unfiltered count, independent of tag membership', async () => {
+    // p3 is untagged: a tag-sum total would undercount (the I-1 bug). The
+    // grandTotal must reflect all three pages.
+    routeReads(
+      [pageDoc('p1', {}, { tags: ['a'] }), pageDoc('p2', {}, { tags: ['a'] }), pageDoc('p3')],
+      [{ id: 't1', slug: 'a', title: 'Alpha', data: {} }],
+    )
+
+    const res = await fetchPages()
+    expect(res.grandTotal).toBe(3)
+    expect(res.total).toBe(3)
+  })
+
+  it('paginates the flat view and keeps total/grandTotal stable', async () => {
+    routeReads([pageDoc('p1'), pageDoc('p2'), pageDoc('p3')])
+
+    const first = await fetchPages({ page: 1, pageSize: 2 })
+    expect(first.pages).toHaveLength(2)
+    expect(first.total).toBe(3)
+    expect(first.grandTotal).toBe(3)
+
+    const second = await fetchPages({ page: 2, pageSize: 2 })
+    expect(second.pages).toHaveLength(1)
+    expect(second.total).toBe(3)
+    expect(second.grandTotal).toBe(3)
+  })
+
+  it('total reflects the filter while grandTotal does not', async () => {
+    routeReads([
+      pageDoc('p1', { status: 'DRAFT' }),
+      pageDoc('p2', { status: 'PUBLISHED' }),
+      pageDoc('p3', { status: 'PUBLISHED' }),
+    ])
+
+    const res = await fetchPages({ status: 'DRAFT' })
+    expect(res.total).toBe(1)
+    expect(res.grandTotal).toBe(3)
+  })
+})
+
+describe('bulk operations', () => {
+  it('counts ok/failed across a batch and issues one request per id', async () => {
+    cmsApi.mockImplementation((endpoint: string) =>
+      Promise.resolve(
+        endpoint.includes('bad') ? { error: 'nope', status: 500 } : { data: {}, status: 200 },
+      ),
+    )
+
+    const result = await bulkUpdatePages(['a', 'bad', 'c'], { status: 'PUBLISHED' })
+    expect(result).toEqual({ ok: 2, failed: 1 })
+    expect(cmsApi).toHaveBeenCalledTimes(3)
+  })
+
+  it('does not drop or double-process work above the concurrency limit', async () => {
+    cmsApi.mockResolvedValue({ data: {}, status: 200 })
+    const ids = Array.from({ length: 12 }, (_, i) => `p${i}`)
+    const result = await bulkUpdatePages(ids, { status: 'DRAFT' })
+    expect(result).toEqual({ ok: 12, failed: 0 })
+    expect(cmsApi).toHaveBeenCalledTimes(12)
+  })
+
+  it('treats a thrown request as a failure rather than aborting the batch', async () => {
+    let call = 0
+    cmsApi.mockImplementation(() => {
+      call++
+      if (call === 2) return Promise.reject(new Error('network'))
+      return Promise.resolve({ data: {}, status: 200 })
+    })
+
+    const result = await bulkChangePageTags(
+      [
+        { id: 'a', tags: [], primaryTagId: null },
+        { id: 'b', tags: [], primaryTagId: null },
+        { id: 'c', tags: [], primaryTagId: null },
+      ],
+      { add: ['x'] },
+    )
+    expect(result.ok).toBe(2)
+    expect(result.failed).toBe(1)
+  })
+})

package/src/__tests__/lib/useApiData.test.ts

@@ -10,10 +10,11 @@ vi.mock('../../lib/api.js', () => ({
   cmsApi: (...args: unknown[]) => cmsApiMock(...args),
 }))
 
-const { useApiData } = await import('../../lib/useApiData.js')
+const { useApiData, __clearApiDataCache } = await import('../../lib/useApiData.js')
 
 beforeEach(() => {
   cmsApiMock.mockReset()
+  __clearApiDataCache()
 })
 
 afterEach(() => {
@@ -102,4 +103,38 @@ describe('useApiData', () => {
     expect(result.current.exhausted).toBe(false)
     expect(result.current.error).toBeNull()
   })
+
+  it('serves a warm cache on remount without refetching when cacheMs is set', async () => {
+    cmsApiMock.mockResolvedValue({ data: { v: 1 }, status: 200 })
+
+    const first = renderHook(() => useApiData<{ v: number }>('/cached', null, { cacheMs: 10_000 }))
+    await waitFor(() => expect(first.result.current.loading).toBe(false))
+    expect(first.result.current.data).toEqual({ v: 1 })
+    expect(cmsApiMock).toHaveBeenCalledTimes(1)
+    first.unmount()
+
+    // A fresh mount within the TTL reads the cache synchronously — data is
+    // present immediately, loading never flips true, and no new request fires.
+    const second = renderHook(() => useApiData<{ v: number }>('/cached', null, { cacheMs: 10_000 }))
+    expect(second.result.current.data).toEqual({ v: 1 })
+    expect(second.result.current.loading).toBe(false)
+    expect(cmsApiMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('refetch bypasses the cache and updates it', async () => {
+    cmsApiMock.mockResolvedValue({ data: { v: 1 }, status: 200 })
+
+    const { result } = renderHook(() =>
+      useApiData<{ v: number }>('/cached2', null, { cacheMs: 10_000 }),
+    )
+    await waitFor(() => expect(result.current.loading).toBe(false))
+    expect(cmsApiMock).toHaveBeenCalledTimes(1)
+
+    cmsApiMock.mockResolvedValue({ data: { v: 2 }, status: 200 })
+    await act(async () => {
+      result.current.refetch()
+    })
+    await waitFor(() => expect(result.current.data).toEqual({ v: 2 }))
+    expect(cmsApiMock).toHaveBeenCalledTimes(2)
+  })
 })

package/src/__tests__/views/page-section-editor.test.tsx

@@ -0,0 +1,65 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { render, screen } from '@testing-library/react'
+
+const fetchPageForEditor = vi.fn()
+vi.mock('../../lib/page-editor-service.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../lib/page-editor-service.js')>()
+  return {
+    ...actual,
+    fetchPageForEditor: (...args: unknown[]) => fetchPageForEditor(...args),
+  }
+})
+
+const { PageSectionEditor } = await import('../../views/page-editor/PageSectionEditor.js')
+
+const validConfig = {
+  collections: {
+    pages: {
+      slug: 'pages',
+      fields: {
+        title: { type: 'text' },
+        slug: { type: 'slug' },
+        path: { type: 'text' },
+        sections: { type: 'json' },
+        metaTitle: { type: 'text' },
+        metaDescription: { type: 'text' },
+      },
+    },
+  },
+}
+
+afterEach(() => {
+  fetchPageForEditor.mockReset()
+})
+
+describe('PageSectionEditor schema guard', () => {
+  it('refuses to operate when the pages collection is missing the sections field', async () => {
+    const badConfig = {
+      collections: { pages: { slug: 'pages', fields: { title: { type: 'text' } } } },
+    }
+
+    render(
+      <PageSectionEditor documentId="p1" config={badConfig} onNavigate={() => {}} session={{}} />,
+    )
+
+    expect(await screen.findByText(/missing required field/i)).toBeTruthy()
+    expect(screen.getByText(/sections/)).toBeTruthy()
+    // The guard must short-circuit before any network read.
+    expect(fetchPageForEditor).not.toHaveBeenCalled()
+  })
+
+  it('does not block when no config is provided (embedding/test contexts)', async () => {
+    render(<PageSectionEditor config={undefined} onNavigate={() => {}} session={{}} />)
+    // New page (no documentId) → empty editor shell renders.
+    expect(await screen.findByText('Sections')).toBeTruthy()
+  })
+})
+
+describe('PageSectionEditor new page', () => {
+  it('renders the editor shell without fetching for /pages/new', async () => {
+    render(<PageSectionEditor config={validConfig} onNavigate={() => {}} session={{}} />)
+    expect(await screen.findByText('Sections')).toBeTruthy()
+    expect(fetchPageForEditor).not.toHaveBeenCalled()
+  })
+})

package/src/__tests__/views/pages-list-view.test.tsx

@@ -0,0 +1,119 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { render, screen, fireEvent, waitFor } from '@testing-library/react'
+
+// Keep the pure shaping helpers (applyPagesQuery/groupPages) real — the
+// list view relies on them for in-memory filtering — and stub only the
+// network read + bulk mutations.
+const fetchPagesDataset = vi.fn()
+vi.mock('../../lib/pages-service.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../lib/pages-service.js')>()
+  return {
+    ...actual,
+    fetchPagesDataset: () => fetchPagesDataset(),
+  }
+})
+
+const { PagesListView } = await import('../../views/Pages/PagesListView.js')
+import type { Page, PageTag, PagesDataset } from '../../lib/pages-service.js'
+
+afterEach(() => {
+  fetchPagesDataset.mockReset()
+})
+
+function page(id: string, over: Partial<Page> = {}): Page {
+  return {
+    id,
+    title: id,
+    path: `/${id}`,
+    slug: id,
+    parentPageId: null,
+    tags: [],
+    primaryTagId: null,
+    authorId: 'u1',
+    authorName: 'Jane Doe',
+    authorInitials: 'JD',
+    status: 'PUBLISHED',
+    publishDate: null,
+    scheduledDate: null,
+    lastModified: '2026-01-01T00:00:00Z',
+    seoScore: 80,
+    seoTitle: null,
+    seoDescription: null,
+    templateId: null,
+    isHomepage: false,
+    isSystemPage: false,
+    createdAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:00:00Z',
+    ...over,
+  }
+}
+
+function tag(slug: string, pageCount: number): PageTag {
+  return {
+    id: slug,
+    docId: `doc-${slug}`,
+    name: slug.toUpperCase(),
+    slug,
+    description: null,
+    color: 'green',
+    pageCount,
+    sortOrder: 0,
+    active: true,
+    createdAt: null,
+    updatedAt: null,
+  }
+}
+
+function dataset(over: Partial<PagesDataset> = {}): PagesDataset {
+  return { pages: [], tags: [], authors: [], ...over }
+}
+
+describe('PagesListView', () => {
+  it('counts untagged pages in the grand total (I-1 regression)', async () => {
+    // Two pages tagged "a", one untagged. A tag-sum total would report 2;
+    // the grand total must be 3.
+    fetchPagesDataset.mockResolvedValue(
+      dataset({
+        pages: [
+          page('p1', { tags: ['a'], primaryTagId: 'a' }),
+          page('p2', { tags: ['a'], primaryTagId: 'a' }),
+          page('p3'),
+        ],
+        tags: [tag('a', 2)],
+      }),
+    )
+
+    render(<PagesListView onNavigate={() => {}} />)
+
+    expect(await screen.findByText(/3 pages · organized by tags/)).toBeTruthy()
+    expect(screen.getByText('3 of 3')).toBeTruthy()
+  })
+
+  it('renders the empty state when there are no pages', async () => {
+    fetchPagesDataset.mockResolvedValue(dataset())
+    render(<PagesListView onNavigate={() => {}} />)
+    expect(await screen.findByText('No pages yet')).toBeTruthy()
+  })
+
+  it('shows an error with a retry that refetches', async () => {
+    fetchPagesDataset.mockRejectedValueOnce(new Error('Boom'))
+    render(<PagesListView onNavigate={() => {}} />)
+
+    expect(await screen.findByText('Boom')).toBeTruthy()
+
+    fetchPagesDataset.mockResolvedValueOnce(dataset({ pages: [page('p1')] }))
+    fireEvent.click(screen.getByText('Try again'))
+
+    await waitFor(() => expect(screen.getByText('1 of 1')).toBeTruthy())
+  })
+
+  it('navigates to the section editor when a row is opened', async () => {
+    const onNavigate = vi.fn()
+    fetchPagesDataset.mockResolvedValue(dataset({ pages: [page('about', { title: 'About' })] }))
+    render(<PagesListView onNavigate={onNavigate} />)
+
+    fireEvent.click(await screen.findByText('About'))
+    expect(onNavigate).toHaveBeenCalledWith('/pages/about/edit')
+  })
+})

package/src/lib/page-editor-service.ts

@@ -123,6 +123,62 @@ export function validatePage(page: EditorPage, forPublish = false): ValidationRe
   return { errors, warnings }
 }
 
+// ─── Schema guard ────────────────────────────────────────────────────
+
+/**
+ * The Page Editor persists `sections` / `path` / `metaTitle` /
+ * `metaDescription` as top-level keys on a `pages` document. The server's
+ * field-access layer only writes keys that are *declared as fields* on the
+ * collection — any undeclared key is silently dropped on save. A `pages`
+ * collection missing the `sections` field would therefore discard all page
+ * content with no error.
+ *
+ * `missingPageFields` returns the required field keys absent from the
+ * `pages` collection so the editor can refuse to operate (and explain why)
+ * rather than corrupt data. When `config` (or its collections) is not
+ * provided — some embedding/test contexts don't pass it — we can't check,
+ * so we return `[]` and trust the consumer.
+ */
+const REQUIRED_PAGE_FIELDS = ['sections', 'path', 'metaTitle', 'metaDescription'] as const
+
+export function missingPageFields(config: unknown): string[] {
+  const pages = findPagesCollection(config)
+  if (!pages) return []
+  const declared = declaredFieldNames(pages.fields)
+  if (declared === null) return []
+  return REQUIRED_PAGE_FIELDS.filter((k) => !declared.has(k))
+}
+
+function findPagesCollection(config: unknown): { fields?: unknown } | null {
+  const collections = (config as { collections?: unknown } | null | undefined)?.collections
+  if (!collections) return null
+  if (Array.isArray(collections)) {
+    return (
+      (collections as Array<{ slug?: string; fields?: unknown }>).find(
+        (c) => c?.slug === PAGES_COLLECTION,
+      ) ?? null
+    )
+  }
+  if (typeof collections === 'object') {
+    return (collections as Record<string, { fields?: unknown }>)[PAGES_COLLECTION] ?? null
+  }
+  return null
+}
+
+/** Field definitions may be a record (keyed by name) or an array of `{ name }`. */
+function declaredFieldNames(fields: unknown): Set<string> | null {
+  if (!fields) return null
+  if (Array.isArray(fields)) {
+    return new Set(
+      (fields as Array<{ name?: string }>)
+        .map((f) => f?.name)
+        .filter((n): n is string => typeof n === 'string'),
+    )
+  }
+  if (typeof fields === 'object') return new Set(Object.keys(fields as Record<string, unknown>))
+  return null
+}
+
 // ─── API row mapping ─────────────────────────────────────────────────
 
 interface DocumentApiRow {
@@ -169,6 +225,11 @@ interface PageWritePayload {
   metaDescription: string
 }
 
+// NOTE: `slug` may be empty for a brand-new draft. The `pages` collection
+// declares `slug` as a `type: 'slug'` field with `from: 'title'`, so the
+// server derives the slug from the title on create when none is supplied;
+// the derived value comes back in the response and populates `EditorPage`.
+// This is why `validatePage` requires a title but not a slug.
 function toWriteBody(page: EditorPage, extra?: Record<string, unknown>): string {
   const payload: PageWritePayload & Record<string, unknown> = {
     title: page.title,