@prenta/admin 1.17.14 → 1.17.17

package/src/__tests__/views/admin-lazy-views.test.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { describe, expect, it } from 'vitest'
+
+const srcRoot = fileURLToPath(new URL('../../', import.meta.url))
+
+const HEAVY_VIEWS = [
+  'views/page-editor/PageSectionEditor.tsx',
+  'views/post-editor/PostSectionEditor.tsx',
+  'views/post-editor/PostTemplateEditor.tsx',
+  'views/Settings.tsx',
+  'views/SEO.tsx',
+  'views/MediaBrowser.tsx',
+  'views/DocumentEdit.tsx',
+  'views/Forms.tsx',
+]
+
+function resolveSpecifier(fromFile: string, specifier: string): string | undefined {
+  const base = resolve(dirname(fromFile), specifier)
+  const candidates = [
+    base,
+    base.replace(/\.js$/, '.tsx'),
+    base.replace(/\.js$/, '.ts'),
+    `${base}.tsx`,
+    `${base}.ts`,
+    join(base, 'index.tsx'),
+    join(base, 'index.ts'),
+  ]
+  return candidates.find((candidate) => existsSync(candidate))
+}
+
+/** Static import graph. Dynamic `import()` edges are stripped first. */
+function staticGraph(entry: string): Set<string> {
+  const seen = new Set<string>()
+  const stack = [entry]
+  while (stack.length > 0) {
+    const file = stack.pop()
+    if (!file || seen.has(file)) continue
+    seen.add(file)
+    const text = readFileSync(file, 'utf8').replace(/import\s*\(\s*['"][^'"]+['"]\s*\)/g, '')
+    for (const match of text.matchAll(/from ['"](\.[^'"]+)['"]/g)) {
+      const specifier = match[1]
+      if (!specifier) continue
+      const next = resolveSpecifier(file, specifier)
+      if (next) stack.push(next)
+    }
+  }
+  return seen
+}
+
+describe('admin route-level code splitting', () => {
+  it('keeps heavy views out of the AdminRoot static import graph', () => {
+    const graph = staticGraph(join(srcRoot, 'AdminRoot.tsx'))
+    const present = HEAVY_VIEWS.filter((view) => graph.has(join(srcRoot, view)))
+    expect(present).toEqual([])
+
+    const bytes = HEAVY_VIEWS.reduce((total, view) => total + statSync(join(srcRoot, view)).size, 0)
+    // The shell no longer statically imports these modules. Their source is
+    // the chunk the app bundler can defer. This floor fails if the split is
+    // reverted and the files are pulled back into the entry graph above.
+    expect(bytes).toBeGreaterThan(40_000)
+
+    const lazySource = readFileSync(join(srcRoot, 'views/lazy-views.tsx'), 'utf8')
+    expect(lazySource).toContain("import('./page-editor/PageSectionEditor.js')")
+    expect(lazySource).toContain("import('./SEO.js')")
+    expect(lazySource).toContain("import('./Settings.js')")
+    expect(lazySource).toContain("import('./MediaBrowser.js')")
+  })
+})

package/src/__tests__/views/audit-log-export.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { auditExportPath } from '../../views/settings/AuditLogExportCard.js'
+
+describe('auditExportPath', () => {
+  it('omits empty dates and keeps the format', () => {
+    expect(auditExportPath({ format: 'csv', from: '', to: '' })).toBe(
+      '/security/audit-log/export?format=csv',
+    )
+  })
+
+  it('includes a date range', () => {
+    expect(auditExportPath({ format: 'json', from: '2026-01-01', to: '2026-01-31' })).toBe(
+      '/security/audit-log/export?format=json&from=2026-01-01&to=2026-01-31',
+    )
+  })
+})

package/src/__tests__/views/collection-list-paging.test.tsx

@@ -0,0 +1,112 @@
+// @vitest-environment happy-dom
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { fireEvent, render, screen } from '@testing-library/react'
+import { buildCollectionListUrl } from '../../views/CollectionList.js'
+
+/**
+ * Collection list pages with the keyset cursor from `listDocuments`, not
+ * OFFSET `page`. Deep pages of a large collection must not send `skip`.
+ */
+
+const seen: string[] = []
+
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: vi.fn(async () => ({ data: {}, status: 200 })),
+  ensureCsrfToken: vi.fn(async () => {}),
+}))
+
+vi.mock('../../lib/useApiData.js', () => ({
+  useApiData: (endpoint: string) => {
+    seen.push(endpoint)
+    const cursor = new URL(`http://localhost${endpoint}`).searchParams.get('cursor')
+    return {
+      data: {
+        docs: [
+          {
+            id: '1',
+            title: 'Hello',
+            status: 'DRAFT',
+            updatedAt: '2026-01-01T00:00:00Z',
+            data: { title: 'Hello' },
+          },
+        ],
+        total: 60,
+        nextCursor: cursor ? null : 'cursor-2',
+      },
+      loading: false,
+      error: null,
+      refetch: vi.fn(),
+    }
+  },
+}))
+
+const CONFIG = {
+  collections: {
+    posts: {
+      slug: 'posts',
+      labels: { singular: 'Post', plural: 'Posts' },
+      fields: { title: { type: 'text', label: 'Title' } },
+    },
+  },
+}
+
+beforeEach(() => {
+  seen.length = 0
+})
+
+describe('buildCollectionListUrl', () => {
+  it('omits OFFSET page and sends the keyset cursor', () => {
+    const first = buildCollectionListUrl({
+      collectionSlug: 'posts',
+      pick: 'title,slug',
+      cursor: null,
+      search: '',
+      sort: null,
+      order: 'asc',
+      filters: {},
+    })
+    const params = new URL(`http://localhost${first}`).searchParams
+    expect(params.get('page')).toBeNull()
+    expect(params.get('pageSize')).toBe('25')
+    expect(params.get('cursor')).toBeNull()
+    expect(params.get('pick')).toBe('title,slug')
+
+    const next = buildCollectionListUrl({
+      collectionSlug: 'posts',
+      pick: 'title,slug',
+      cursor: 'doc-25',
+      search: 'hello',
+      sort: 'updatedAt',
+      order: 'desc',
+      filters: { status: 'PUBLISHED' },
+    })
+    const nextParams = new URL(`http://localhost${next}`).searchParams
+    expect(nextParams.get('page')).toBeNull()
+    expect(nextParams.get('cursor')).toBe('doc-25')
+    expect(nextParams.get('search')).toBe('hello')
+    expect(nextParams.get('sort')).toBe('updatedAt')
+    expect(nextParams.get('order')).toBe('desc')
+    expect(nextParams.get('filter.status')).toBe('PUBLISHED')
+  })
+})
+
+describe('CollectionList paging', () => {
+  it('requests the next page with nextCursor and returns without an offset', async () => {
+    const { CollectionList } = await import('../../views/CollectionList.js')
+    render(<CollectionList collectionSlug="posts" config={CONFIG} onNavigate={vi.fn()} />)
+
+    const first = seen[seen.length - 1] ?? ''
+    expect(new URL(`http://localhost${first}`).searchParams.get('page')).toBeNull()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Next' }))
+
+    const afterNext = seen[seen.length - 1] ?? ''
+    expect(new URL(`http://localhost${afterNext}`).searchParams.get('cursor')).toBe('cursor-2')
+    expect(screen.getByText('Page 2 of 3')).toBeTruthy()
+
+    fireEvent.click(screen.getByRole('button', { name: 'Previous' }))
+    const afterPrev = seen[seen.length - 1] ?? ''
+    expect(new URL(`http://localhost${afterPrev}`).searchParams.get('cursor')).toBeNull()
+    expect(screen.getByText('Page 1 of 3')).toBeTruthy()
+  })
+})

package/src/__tests__/views/trash.render.test.tsx

@@ -96,4 +96,44 @@ describe('Trash', () => {
       )
     })
   })
+
+  it('asks before permanently deleting a trashed document', async () => {
+    cmsApi.mockImplementation(async (endpoint: string, options?: { method?: string }) => {
+      if (options?.method === 'POST' && String(endpoint).includes('/purge')) {
+        return { data: { success: true }, status: 200 }
+      }
+      if (String(endpoint).includes('/collections/pages')) {
+        return {
+          data: {
+            docs: [
+              {
+                id: 'p1',
+                title: 'About',
+                slug: null,
+                deletedAt: '2026-08-01T00:00:00.000Z',
+                data: { slug: 'about' },
+              },
+            ],
+          },
+          status: 200,
+        }
+      }
+      return { data: { docs: [] }, status: 200 }
+    })
+
+    render(<Trash onNavigate={vi.fn()} />)
+    expect(await screen.findByText('About')).toBeTruthy()
+    fireEvent.click(screen.getByRole('button', { name: 'Delete About permanently' }))
+    expect(cmsApi).not.toHaveBeenCalledWith(expect.stringContaining('/purge'), expect.anything())
+    fireEvent.click(screen.getByRole('button', { name: 'Delete permanently' }))
+    await waitFor(() => {
+      expect(cmsApi).toHaveBeenCalledWith(
+        '/collections/pages/p1/purge',
+        expect.objectContaining({ method: 'POST' }),
+      )
+    })
+    await waitFor(() => {
+      expect(screen.queryByText('About')).toBeNull()
+    })
+  })
 })

package/src/lib/pages-service.ts

@@ -33,6 +33,28 @@ export type PageStatus = 'DRAFT' | 'PUBLISHED' | 'SCHEDULED' | 'ARCHIVED'
 const PAGES_COLLECTION = 'pages'
 const PAGE_TAGS_COLLECTION = 'page-tags'
 
+/** Keys the pages table reads. `sections` and other content blobs stay off the wire. */
+const PAGE_LIST_PICK = [
+  'title',
+  'slug',
+  'path',
+  'parentPageId',
+  'tags',
+  'primaryTag',
+  'seoScore',
+  'seo_score',
+  'metaScore',
+  'metaTitle',
+  'seoTitle',
+  'metaDescription',
+  'seoDescription',
+  'templateId',
+  'isHomepage',
+  'isSystemPage',
+].join(',')
+
+const TAG_LIST_PICK = ['title', 'slug', 'description', 'color', 'sortOrder', 'active'].join(',')
+
 export interface PageTag {
   id: string // == slug (stable join key; pages store slugs in data.tags)
   docId: string // underlying document id — required for tag CRUD
@@ -217,7 +239,7 @@ function docToTag(d: DocumentApiRow, pageCount: number): PageTag {
 
 async function fetchTagDocs(): Promise<DocumentApiRow[]> {
   const res = await cmsApi<ListEnvelope>(
-    `/collections/${PAGE_TAGS_COLLECTION}?pageSize=500&sort=updatedAt&order=desc`,
+    `/collections/${PAGE_TAGS_COLLECTION}?pageSize=500&sort=updatedAt&order=desc&pick=${TAG_LIST_PICK}`,
   )
   return (res.data?.docs ?? []) as DocumentApiRow[]
 }
@@ -366,7 +388,9 @@ export async function fetchPagesDataset(): Promise<PagesDataset> {
   const authorsMap = await fetchAuthorsMap()
 
   const [pagesRes, tagDocs] = await Promise.all([
-    cmsApi<ListEnvelope>(`/collections/${PAGES_COLLECTION}?pageSize=500&sort=updatedAt&order=desc`),
+    cmsApi<ListEnvelope>(
+      `/collections/${PAGES_COLLECTION}?pageSize=500&sort=updatedAt&order=desc&pick=${PAGE_LIST_PICK}`,
+    ),
     fetchTagDocs(),
   ])
 

package/src/router/admin-routes.ts

@@ -12,13 +12,13 @@
  * the `admin-routes` drift test keeps `ADMIN_STATIC_ROUTE_PATTERNS` in sync with
  * the literal `matchRoute('…')` calls in AdminRoot.
  */
-import { SEO_DEEP_PATHS } from '../views/SEO.js'
+import { SEO_DEEP_PATHS } from '../views/seo/seo-routes.js'
 
 /**
  * Every static route pattern `AdminRoot.renderView()` resolves via a literal
  * `matchRoute('…')` call. Dynamic collection routes are derived per-config in
- * {@link collectionRoutePatterns}; the SEO deep paths are added from the view's
- * own {@link SEO_DEEP_PATHS} so the two can't drift.
+ * {@link collectionRoutePatterns}; the SEO deep paths are added from
+ * {@link SEO_DEEP_PATHS} so the two can't drift.
  */
 export const ADMIN_STATIC_ROUTE_PATTERNS: readonly string[] = [
   '/',

package/src/views/CollectionList.tsx

@@ -102,6 +102,52 @@ function facetCellValue(doc: any, facet: FacetDef): string {
   return ''
 }
 
+const SKIPPED_LIST_FIELDS = new Set(['richText', 'blocks', 'json', 'media', 'relationship'])
+
+/** Scalar field names the table and inspector show. Content blobs are not requested. */
+const LIST_PAGE_SIZE = 25
+
+/** Collection list query. Keyset `cursor` replaces OFFSET `page` (#445). */
+export function buildCollectionListUrl(input: {
+  collectionSlug: string
+  pick: string
+  cursor: string | null
+  search: string
+  sort: SortField | null
+  order: SortOrder
+  filters: Record<string, string>
+}): string {
+  const params = new URLSearchParams()
+  params.set('pageSize', String(LIST_PAGE_SIZE))
+  params.set('pick', input.pick)
+  if (input.cursor) params.set('cursor', input.cursor)
+  if (input.search) params.set('search', input.search)
+  if (input.sort) {
+    params.set('sort', input.sort)
+    params.set('order', input.order)
+  }
+  for (const [field, value] of Object.entries(input.filters)) {
+    if (value) params.set(`filter.${field}`, value)
+  }
+  return `/collections/${input.collectionSlug}?${params.toString()}`
+}
+
+function listPickParam(config: any, slug: string, facets: FacetDef[]): string {
+  const names = new Set<string>(['title', 'slug'])
+  const fields = resolveCollection(config, slug)?.fields
+  if (fields && typeof fields === 'object') {
+    for (const [name, field] of Object.entries(fields) as Array<[string, any]>) {
+      if (!field || field.hidden) continue
+      if (typeof field.type === 'string' && SKIPPED_LIST_FIELDS.has(field.type)) continue
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) names.add(name)
+    }
+  }
+  for (const facet of facets) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(facet.name)) names.add(facet.name)
+  }
+  return [...names].slice(0, 32).join(',')
+}
+
 function statusColor(status: string): string {
   switch (status?.toUpperCase()) {
     case 'PUBLISHED':
@@ -160,7 +206,8 @@ export function CollectionList({ collectionSlug, config, onNavigate }: Collectio
     [collectionDef, collectionSlug],
   )
 
-  const [page, setPage] = useState(1)
+  const [cursor, setCursor] = useState<string | null>(null)
+  const [priorCursors, setPriorCursors] = useState<Array<string | null>>([])
   const [search, setSearch] = useState('')
   const [debouncedSearch, setDebouncedSearch] = useState('')
   const [sort, setSort] = useState<SortField | null>(null)
@@ -173,38 +220,53 @@ export function CollectionList({ collectionSlug, config, onNavigate }: Collectio
   const [facetValues, setFacetValues] = useState<Record<string, string[]>>({})
   const searchTimer = useRef<ReturnType<typeof setTimeout>>(undefined)
 
+  const resetCursor = useCallback(() => {
+    setCursor(null)
+    setPriorCursors([])
+  }, [])
+
   useEffect(() => {
     clearTimeout(searchTimer.current)
     searchTimer.current = setTimeout(() => {
       setDebouncedSearch(search)
-      setPage(1)
+      resetCursor()
     }, 300)
     return () => clearTimeout(searchTimer.current)
-  }, [search])
-
-  const endpoint = useMemo(() => {
-    let url = `/collections/${collectionSlug}?page=${page}&pageSize=25`
-    if (debouncedSearch) url += `&search=${encodeURIComponent(debouncedSearch)}`
-    if (sort) url += `&sort=${sort}&order=${order}`
-    for (const [field, value] of Object.entries(filters)) {
-      if (value) url += `&filter.${encodeURIComponent(field)}=${encodeURIComponent(value)}`
-    }
-    return url
-  }, [collectionSlug, page, debouncedSearch, sort, order, filters])
+  }, [search, resetCursor])
+
+  const endpoint = useMemo(
+    () =>
+      buildCollectionListUrl({
+        collectionSlug,
+        pick: listPickParam(config, collectionSlug, facets),
+        cursor,
+        search: debouncedSearch,
+        sort,
+        order,
+        filters,
+      }),
+    [collectionSlug, cursor, debouncedSearch, sort, order, filters, config, facets],
+  )
 
-  const { data, loading, error, refetch } = useApiData<{ docs: any[]; total: number }>(endpoint)
+  const { data, loading, error, refetch } = useApiData<{
+    docs: any[]
+    total: number
+    nextCursor?: string | null
+  }>(endpoint)
   const docs = data?.docs ?? []
   const total = data?.total ?? 0
-  const totalPages = Math.max(1, Math.ceil(total / 25))
+  const totalPages = Math.max(1, Math.ceil(total / LIST_PAGE_SIZE))
+  const pageNumber = priorCursors.length + 1
+  const nextCursor = data?.nextCursor ?? null
 
   useEffect(() => {
-    setPage(1)
+    resetCursor()
     setSelected(new Set())
     setDetailId(null)
     setSearch('')
     setFilters({})
     setFacetValues({})
-  }, [collectionSlug])
+  }, [collectionSlug, resetCursor])
 
   // Load in-use values for facets that aren't config-defined selects.
   useEffect(() => {
@@ -226,26 +288,33 @@ export function CollectionList({ collectionSlug, config, onNavigate }: Collectio
     }
   }, [collectionSlug, facets])
 
-  const setFilter = useCallback((field: string, value: string) => {
-    setFilters((prev) => {
-      const next = { ...prev }
-      if (value) next[field] = value
-      else delete next[field]
-      return next
-    })
-    setPage(1)
-  }, [])
+  const setFilter = useCallback(
+    (field: string, value: string) => {
+      setFilters((prev) => {
+        const next = { ...prev }
+        if (value) next[field] = value
+        else delete next[field]
+        return next
+      })
+      resetCursor()
+    },
+    [resetCursor],
+  )
 
-  const toggleSort = useCallback((field: SortField) => {
-    setSort((prev) => {
-      if (prev === field) {
-        setOrder((o) => (o === 'asc' ? 'desc' : 'asc'))
+  const toggleSort = useCallback(
+    (field: SortField) => {
+      resetCursor()
+      setSort((prev) => {
+        if (prev === field) {
+          setOrder((o) => (o === 'asc' ? 'desc' : 'asc'))
+          return field
+        }
+        setOrder('asc')
         return field
-      }
-      setOrder('asc')
-      return field
-    })
-  }, [])
+      })
+    },
+    [resetCursor],
+  )
 
   const detailDoc = useMemo(
     () => (detailId ? (docs.find((d: any) => String(d.id) === detailId) ?? null) : null),
@@ -631,20 +700,32 @@ export function CollectionList({ collectionSlug, config, onNavigate }: Collectio
           style={{ color: 'var(--prenta-text-secondary, #6b7280)' }}
         >
           <span>
-            Page {page} of {totalPages}
+            Page {pageNumber} of {totalPages}
           </span>
           <div className="flex gap-2">
             <button
-              disabled={page <= 1}
-              onClick={() => setPage((p) => p - 1)}
+              type="button"
+              disabled={priorCursors.length === 0}
+              onClick={() => {
+                setPriorCursors((stack) => {
+                  if (stack.length === 0) return stack
+                  setCursor(stack[stack.length - 1] ?? null)
+                  return stack.slice(0, -1)
+                })
+              }}
               className="flex items-center gap-1 rounded-lg border px-3 py-1.5 transition-opacity disabled:opacity-40"
               style={{ borderColor: 'var(--prenta-border, #d1d5db)' }}
             >
               <ChevronLeft className="h-4 w-4" /> Previous
             </button>
             <button
-              disabled={page >= totalPages}
-              onClick={() => setPage((p) => p + 1)}
+              type="button"
+              disabled={!nextCursor}
+              onClick={() => {
+                if (!nextCursor) return
+                setPriorCursors((stack) => [...stack, cursor])
+                setCursor(nextCursor)
+              }}
               className="flex items-center gap-1 rounded-lg border px-3 py-1.5 transition-opacity disabled:opacity-40"
               style={{ borderColor: 'var(--prenta-border, #d1d5db)' }}
             >

package/src/views/SEO.tsx

@@ -37,6 +37,7 @@ import { AuditTab } from './seo/AuditTab.js'
 import { LinksTab } from './seo/LinksTab.js'
 import { ProposalsTab } from './seo/ProposalsTab.js'
 import { AiVisibilityTab } from './seo/AiVisibilityTab.js'
+export { SEO_DEEP_PATHS, seoTabForPath } from './seo/seo-routes.js'
 
 export interface SEOProps {
   onNavigate?: (path: string) => void
@@ -61,54 +62,6 @@ function normalizeTab(tab: string | undefined): TabId {
   return (valid.includes(tab ?? '') ? tab : 'overview') as TabId
 }
 
-/**
- * SEO deep paths the admin router resolves onto the tabbed SEO view — including
- * every path plugin-seo advertises in the sidebar. `matchRoute` is exact, so any
- * of these NOT listed here falls through to the generic 404 (which is exactly
- * how `/seo/link-health` and `/seo/sitemap` used to break).
- */
-export const SEO_DEEP_PATHS = [
-  '/seo/link-health',
-  '/seo/sitemap',
-  '/seo/redirects',
-  '/seo/content',
-  '/seo/canonicals',
-  '/seo/technical',
-  '/seo/links',
-  '/seo/audit',
-  '/seo/proposals',
-  '/seo/ai-visibility',
-  '/seo',
-] as const
-
-/** Map an SEO deep path to the tab it should open, or null if it isn't one. */
-export function seoTabForPath(pathname: string): TabId | null {
-  switch (pathname) {
-    case '/seo/link-health':
-      return 'links'
-    case '/seo/sitemap':
-      return 'technical'
-    case '/seo/redirects':
-      return 'redirects'
-    case '/seo/content':
-    case '/seo/canonicals':
-      return 'content'
-    case '/seo/technical':
-    case '/seo/links':
-      return 'technical'
-    case '/seo/audit':
-      return 'audit'
-    case '/seo/proposals':
-      return 'proposals'
-    case '/seo/ai-visibility':
-      return 'ai-visibility'
-    case '/seo':
-      return 'overview'
-    default:
-      return null
-  }
-}
-
 interface UrlState {
   tab: string | null
   entityType: string | null