@actuate-media/cms-admin 0.17.0 → 0.18.0

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,

package/src/lib/pages-service.ts

@@ -94,13 +94,28 @@ export interface PagesQuery {
 
 export interface PagesResult {
   pages: Page[]
+  /** number of pages matching the active query (post-filter) */
   total: number
+  /** total pages in the collection, ignoring the active query/filters */
+  grandTotal: number
   page: number
   pageSize: number
   tags: PageTag[]
   authors: PageAuthor[]
 }
 
+/**
+ * The full, unfiltered page set plus its tags and authors. The list view
+ * fetches this once and applies search / sort / group / paging in memory
+ * (see `applyPagesQuery` + `groupPages`), so typing in the search box or
+ * changing the sort never re-downloads the dataset.
+ */
+export interface PagesDataset {
+  pages: Page[]
+  tags: PageTag[]
+  authors: PageAuthor[]
+}
+
 // ─── API row shapes ──────────────────────────────────────────────────
 
 interface DocumentApiRow {
@@ -371,7 +386,13 @@ function statusLabel(s: PageStatus): string {
   return s.charAt(0) + s.slice(1).toLowerCase()
 }
 
-export async function fetchPages(query: PagesQuery = {}): Promise<PagesResult> {
+/**
+ * Fetch the entire page dataset (unfiltered) plus tags and authors. This
+ * is the single network read backing the list view; callers apply query
+ * shaping in memory. Tag page counts and the author list are derived from
+ * the full set so they reflect the dataset, not any active filter.
+ */
+export async function fetchPagesDataset(): Promise<PagesDataset> {
   const authorsMap = await fetchAuthorsMap()
 
   const [pagesRes, tagDocs] = await Promise.all([
@@ -383,8 +404,6 @@ export async function fetchPages(query: PagesQuery = {}): Promise<PagesResult> {
     docToPage(d, authorsMap),
   )
 
-  // Tag page counts come from the full (unfiltered) set so chips and the
-  // tag manager reflect the dataset, not the active query.
   const counts = new Map<string, number>()
   for (const p of allPages) {
     for (const slug of p.tags) counts.set(slug, (counts.get(slug) ?? 0) + 1)
@@ -393,16 +412,6 @@ export async function fetchPages(query: PagesQuery = {}): Promise<PagesResult> {
     .map((d) => docToTag(d, counts.get(d.slug ?? d.id) ?? 0))
     .sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name))
 
-  const filtered = applyPagesQuery(allPages, query)
-
-  // Pagination only applies to the flat (ungrouped) view; grouped views
-  // render every match so the buckets stay complete.
-  const grouped = query.groupBy && query.groupBy !== 'none'
-  const page = Math.max(1, query.page ?? 1)
-  const pageSize = Math.max(1, query.pageSize ?? 25)
-  const paged = grouped ? filtered : filtered.slice((page - 1) * pageSize, page * pageSize)
-
-  // Authors present in the dataset (for the Author filter dropdown).
   const seen = new Set<string>()
   const authors: PageAuthor[] = []
   for (const p of allPages) {
@@ -413,7 +422,35 @@ export async function fetchPages(query: PagesQuery = {}): Promise<PagesResult> {
   }
   authors.sort((a, b) => a.name.localeCompare(b.name))
 
-  return { pages: paged, total: filtered.length, page, pageSize, tags, authors }
+  return { pages: allPages, tags, authors }
+}
+
+/**
+ * Query a paginated, filtered page list. Retained for non-list callers
+ * (tag detach/merge) and tests; the list view uses `fetchPagesDataset`
+ * directly and shapes the result in memory.
+ */
+export async function fetchPages(query: PagesQuery = {}): Promise<PagesResult> {
+  const { pages: allPages, tags, authors } = await fetchPagesDataset()
+
+  const filtered = applyPagesQuery(allPages, query)
+
+  // Pagination only applies to the flat (ungrouped) view; grouped views
+  // render every match so the buckets stay complete.
+  const grouped = query.groupBy && query.groupBy !== 'none'
+  const page = Math.max(1, query.page ?? 1)
+  const pageSize = Math.max(1, query.pageSize ?? 25)
+  const paged = grouped ? filtered : filtered.slice((page - 1) * pageSize, page * pageSize)
+
+  return {
+    pages: paged,
+    total: filtered.length,
+    grandTotal: allPages.length,
+    page,
+    pageSize,
+    tags,
+    authors,
+  }
 }
 
 export async function fetchPageById(pageId: string): Promise<Page | null> {
@@ -432,34 +469,54 @@ export interface BulkResult {
   failed: number
 }
 
+/**
+ * Run `task` over `items` with a bounded number of concurrent requests so
+ * a large selection doesn't fire one-at-a-time (slow) or all-at-once
+ * (overwhelms the API / rate limiter). Each task resolves to `true` on
+ * success; failures are counted, never thrown, so one bad row can't abort
+ * the batch.
+ */
+async function mapWithConcurrency<T>(
+  items: T[],
+  limit: number,
+  task: (item: T) => Promise<boolean>,
+): Promise<BulkResult> {
+  let ok = 0
+  let failed = 0
+  let cursor = 0
+  const workerCount = Math.max(1, Math.min(limit, items.length))
+  const worker = async () => {
+    while (cursor < items.length) {
+      const item = items[cursor++]!
+      const success = await task(item).catch(() => false)
+      if (success) ok++
+      else failed++
+    }
+  }
+  await Promise.all(Array.from({ length: workerCount }, worker))
+  return { ok, failed }
+}
+
 export async function bulkUpdatePages(
   ids: string[],
   payload: { status?: PageStatus; data?: Record<string, unknown> },
 ): Promise<BulkResult> {
-  let ok = 0
-  let failed = 0
-  for (const id of ids) {
+  return mapWithConcurrency(ids, 5, async (id) => {
     const res = await cmsApi(`/collections/${PAGES_COLLECTION}/${encodeURIComponent(id)}`, {
       method: 'PUT',
       body: JSON.stringify(payload),
     })
-    if (res.error) failed++
-    else ok++
-  }
-  return { ok, failed }
+    return !res.error
+  })
 }
 
 export async function bulkDeletePages(ids: string[]): Promise<BulkResult> {
-  let ok = 0
-  let failed = 0
-  for (const id of ids) {
+  return mapWithConcurrency(ids, 5, async (id) => {
     const res = await cmsApi(`/collections/${PAGES_COLLECTION}/${encodeURIComponent(id)}`, {
       method: 'DELETE',
     })
-    if (res.error) failed++
-    else ok++
-  }
-  return { ok, failed }
+    return !res.error
+  })
 }
 
 /**
@@ -472,11 +529,9 @@ export async function bulkChangePageTags(
   pages: Pick<Page, 'id' | 'tags' | 'primaryTagId'>[],
   change: { add?: string[]; remove?: string[] },
 ): Promise<BulkResult> {
-  let ok = 0
-  let failed = 0
   const add = new Set(change.add ?? [])
   const remove = new Set(change.remove ?? [])
-  for (const p of pages) {
+  return mapWithConcurrency(pages, 5, async (p) => {
     const next = new Set(p.tags)
     for (const t of add) next.add(t)
     for (const t of remove) next.delete(t)
@@ -487,10 +542,8 @@ export async function bulkChangePageTags(
       method: 'PUT',
       body: JSON.stringify({ data: { tags, primaryTag } }),
     })
-    if (res.error) failed++
-    else ok++
-  }
-  return { ok, failed }
+    return !res.error
+  })
 }
 
 // ─── Tag CRUD ────────────────────────────────────────────────────────