@actuate-media/cms-admin 0.65.0 → 0.67.0

package/src/layout/Layout.tsx

@@ -1,7 +1,7 @@
 'use client'
 
 import { useMemo, useState, useEffect, type ReactNode } from 'react'
-import { ExternalLink, Plus } from 'lucide-react'
+import { Plus } from 'lucide-react'
 import { Sidebar } from './Sidebar.js'
 import { Header } from './Header.js'
 import { Breadcrumbs } from '../components/Breadcrumbs.js'
@@ -102,8 +102,9 @@ interface PageActionsContext {
  * primary/secondary pair that mirrors the reference dashboard.
  *
  * Resolution rules:
- *   - Dashboard / home → "+ New Post" + "View Site"
- *   - List views → just "+ New <Type>"
+ *   - Dashboard / Posts / Pages → nothing here; those views render their
+ *     hero CTAs inside the page header per the design
+ *   - Other list views → just "+ New <Type>"
  *   - Editor views → no top-bar action (editor renders its own toolbar)
  */
 function computePageActions({
@@ -112,56 +113,12 @@ function computePageActions({
   onNavigate,
 }: PageActionsContext): ReactNode | null {
   const collections = collectionList(config)
-  const postCollections = collections.filter((c) => c.type === 'post')
-  const newPostPath = resolveNewPostPath(postCollections)
-  const siteUrl: string | null = config?.site?.url ?? config?.seo?.siteUrl ?? null
 
+  // Dashboard, /posts, and /pages render their own hero CTAs in the page
+  // header (design `.page-hdr` → `.hdr-r`), so the top bar stays empty there.
   const isDashboard = currentPath === '/' || currentPath === '/dashboard'
-
-  // Dashboard: keep the existing "+ New Post" / "View Site" pair. With
-  // a single Post Type we route straight to its editor; with several we
-  // route to the picker so the user can choose the type first.
-  if (isDashboard) {
-    return (
-      <>
-        <button
-          type="button"
-          onClick={() => onNavigate(newPostPath)}
-          className="bg-primary text-primary-foreground hover:bg-primary/90 focus-visible:ring-ring inline-flex items-center gap-1.5 rounded-lg px-3.5 py-1.5 text-sm font-medium shadow-sm transition-colors focus:outline-none focus-visible:ring-2"
-        >
-          <Plus className="h-3.5 w-3.5" aria-hidden />
-          New Post
-        </button>
-        {siteUrl ? (
-          <a
-            href={siteUrl}
-            target="_blank"
-            rel="noopener noreferrer"
-            className="border-border bg-background text-foreground hover:bg-accent inline-flex items-center gap-1.5 rounded-lg border px-3 py-1.5 text-sm font-medium transition-colors"
-          >
-            <ExternalLink className="h-3.5 w-3.5" aria-hidden />
-            View Site
-          </a>
-        ) : null}
-      </>
-    )
-  }
-
-  // Posts area — "+ New Post" + "Manage types" on the list page;
-  // "+ New Post Type" on the types page. The buttons live in the top
-  // bar so the page header stays clean. See the dashboard rule for
-  // why these come from a single config-aware helper.
-  if (currentPath === '/posts') {
-    return (
-      <button
-        type="button"
-        onClick={() => onNavigate(newPostPath)}
-        className="bg-primary text-primary-foreground hover:bg-primary/90 focus-visible:ring-ring inline-flex items-center gap-1.5 rounded-lg px-3.5 py-1.5 text-sm font-medium shadow-sm transition-colors focus:outline-none focus-visible:ring-2"
-      >
-        <Plus className="h-3.5 w-3.5" aria-hidden />
-        New Post
-      </button>
-    )
+  if (isDashboard || currentPath === '/posts' || currentPath === '/pages') {
+    return null
   }
 
   if (currentPath === '/posts/types') {
@@ -177,22 +134,6 @@ function computePageActions({
     )
   }
 
-  // Pages list — "+ New page" routes to the page creation flow. Handled
-  // explicitly (not via the collection loop) so the label/route stay
-  // exact even though `pages` is a reserved route.
-  if (currentPath === '/pages') {
-    return (
-      <button
-        type="button"
-        onClick={() => onNavigate('/pages/new')}
-        className="bg-primary text-primary-foreground hover:bg-primary/90 focus-visible:ring-ring inline-flex items-center gap-1.5 rounded-lg px-3.5 py-1.5 text-sm font-medium shadow-sm transition-colors focus:outline-none focus-visible:ring-2"
-      >
-        <Plus className="h-3.5 w-3.5" aria-hidden />
-        New page
-      </button>
-    )
-  }
-
   // List views — surface "+ New X" so authors can keep creating without
   // hunting for a per-list button. Skip on editor views; those have their
   // own toolbar.
@@ -221,19 +162,6 @@ interface CollectionMeta {
   admin?: { hidden?: boolean }
 }
 
-/**
- * Where "+ New Post" should land, given the configured post-type
- * collections:
- *   - exactly one  → straight to that type's editor (`/<slug>/new`)
- *   - more than one → the type picker (`/posts/new`)
- *   - none          → the Post Type setup instructions
- */
-function resolveNewPostPath(postCollections: CollectionMeta[]): string {
-  if (postCollections.length === 1) return `/${postCollections[0]!.slug}/new`
-  if (postCollections.length > 1) return '/posts/new'
-  return '/posts/types/new'
-}
-
 function collectionList(config: any): CollectionMeta[] {
   if (!config?.collections) return []
   const raw = config.collections

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

@@ -64,6 +64,12 @@ export interface EditorPage {
   slug: string
   path: string
   status: PageStatus
+  /**
+   * Parent page for the tree hierarchy (`data.parentPageId`), or null for
+   * a top-level page. Preselected when arriving via "Add sub-page"
+   * (`/pages/new?parent=<id>`); editable in Page settings.
+   */
+  parentPageId: string | null
   sections: PageSection[]
   seoTitle: string
   seoDescription: string
@@ -192,6 +198,8 @@ function rowToEditorPage(doc: DocumentApiRow): EditorPage {
     slug,
     path: typeof data.path === 'string' && data.path ? data.path : slug ? `/${slug}` : '/',
     status: doc.status ?? 'DRAFT',
+    parentPageId:
+      typeof data.parentPageId === 'string' && data.parentPageId ? data.parentPageId : null,
     // Preserve unknown (externally-managed) sections so the editor can show
     // them read-only and round-trip them on save instead of dropping them.
     sections: coerceSectionsCore(data.sections, { onUnknown: 'preserve' }),
@@ -215,6 +223,7 @@ interface PageWritePayload {
   title: string
   slug: string
   path: string
+  parentPageId: string | null
   sections: PageSection[]
   metaTitle: string
   metaDescription: string
@@ -230,6 +239,7 @@ function toWriteBody(page: EditorPage, extra?: Record<string, unknown>): string
     title: page.title,
     slug: page.slug,
     path: page.path,
+    parentPageId: page.parentPageId,
     // Unmanaged sections are part of `page.sections`, so they round-trip on
     // every save (no data loss). Strip the derived `unmanaged` marker — it is
     // recomputed from the registry on read, so persisting it would only stale.
@@ -275,14 +285,18 @@ export async function publishPage(page: EditorPage): Promise<EditorPage> {
   return rowToEditorPage(res.data)
 }
 
-/** A blank page scaffold for `/pages/new`. */
-export function emptyPage(): EditorPage {
+/**
+ * A blank page scaffold for `/pages/new`. `parentPageId` is preset when
+ * the flow was entered via "Add sub-page" in the Pages tree view.
+ */
+export function emptyPage(parentPageId: string | null = null): EditorPage {
   return {
     id: null,
     title: '',
     slug: '',
     path: '',
     status: 'DRAFT',
+    parentPageId,
     sections: [],
     seoTitle: '',
     seoDescription: '',

package/src/lib/pages-service.ts

@@ -510,6 +510,24 @@ export async function bulkUpdatePages(
   })
 }
 
+/** Duplicate a single page. Server resets status to DRAFT and appends "(Copy)". */
+export async function duplicatePage(id: string): Promise<{ id?: string; error?: string }> {
+  const res = await cmsApi<DocumentApiRow>(
+    `/collections/${PAGES_COLLECTION}/${encodeURIComponent(id)}/duplicate`,
+    { method: 'POST' },
+  )
+  if (res.error) return { error: res.error }
+  return { id: res.data?.id }
+}
+
+/** Soft-delete a single page. */
+export async function deletePage(id: string): Promise<{ error?: string }> {
+  const res = await cmsApi(`/collections/${PAGES_COLLECTION}/${encodeURIComponent(id)}`, {
+    method: 'DELETE',
+  })
+  return res.error ? { error: res.error } : {}
+}
+
 export async function bulkDeletePages(ids: string[]): Promise<BulkResult> {
   return mapWithConcurrency(ids, 5, async (id) => {
     const res = await cmsApi(`/collections/${PAGES_COLLECTION}/${encodeURIComponent(id)}`, {

package/src/lib/pages-tree.ts

@@ -0,0 +1,145 @@
+/**
+ * Page hierarchy resolution for the Pages tree view.
+ *
+ * Parent resolution strategy (in priority order):
+ *   1. `parentPageId` — explicit link, used when it points at a page that
+ *      exists in the set (and isn't the page itself).
+ *   2. Path-prefix derivation — for rows without a usable `parentPageId`,
+ *      the longest existing path prefix wins: "/about/team" becomes a child
+ *      of the page whose path is "/about". Missing intermediate levels are
+ *      skipped ("/a/b/c" with no "/a/b" attaches to "/a"). The root path
+ *      "/" is never treated as a prefix parent, so top-level pages stay
+ *      siblings of the homepage.
+ *
+ * Safety guarantees:
+ *   - Orphans (parent id not in the set) become roots.
+ *   - Cycles (a → b → a) are broken deterministically: walking up from each
+ *     page in input order, the edge that closes a cycle is severed and that
+ *     page becomes a root. Every page appears in the tree exactly once.
+ *   - Sibling ordering is stable: title (locale-aware), then path.
+ *
+ * Pure functions — no network, no React — so the view and the unit tests
+ * share one implementation.
+ */
+import type { Page } from './pages-service.js'
+
+export interface PageTreeNode {
+  page: Page
+  children: PageTreeNode[]
+}
+
+/** One visible row of the flattened tree table. */
+export interface PageTreeRow {
+  page: Page
+  depth: number
+  hasChildren: boolean
+}
+
+function normalizePath(path: string): string {
+  let p = path.trim()
+  if (!p.startsWith('/')) p = `/${p}`
+  p = p.replace(/\/{2,}/g, '/')
+  if (p.length > 1) p = p.replace(/\/+$/, '')
+  return p
+}
+
+/**
+ * Longest existing path-prefix parent, or null. Only prefixes with at
+ * least one segment count — "/" (the homepage) is never a derived parent.
+ */
+function derivePathParent(page: Page, idByPath: Map<string, string>): string | null {
+  const segments = normalizePath(page.path).split('/').filter(Boolean)
+  for (let i = segments.length - 1; i >= 1; i--) {
+    const prefix = `/${segments.slice(0, i).join('/')}`
+    const candidate = idByPath.get(prefix)
+    if (candidate !== undefined && candidate !== page.id) return candidate
+  }
+  return null
+}
+
+function compareSiblings(a: PageTreeNode, b: PageTreeNode): number {
+  return (
+    a.page.title.localeCompare(b.page.title) ||
+    a.page.path.localeCompare(b.page.path) ||
+    a.page.id.localeCompare(b.page.id)
+  )
+}
+
+/** Build the parent/child hierarchy for the tree view. Returns root nodes. */
+export function buildPageTree(pages: Page[]): PageTreeNode[] {
+  const byId = new Map<string, Page>()
+  for (const p of pages) byId.set(p.id, p)
+
+  // First occurrence wins on duplicate paths, keeping resolution stable
+  // with respect to input order.
+  const idByPath = new Map<string, string>()
+  for (const p of pages) {
+    const norm = normalizePath(p.path)
+    if (!idByPath.has(norm)) idByPath.set(norm, p.id)
+  }
+
+  const parentOf = new Map<string, string | null>()
+  for (const p of pages) {
+    const explicit =
+      p.parentPageId && p.parentPageId !== p.id && byId.has(p.parentPageId) ? p.parentPageId : null
+    parentOf.set(p.id, explicit ?? derivePathParent(p, idByPath))
+  }
+
+  // Cycle guard: walk each page's ancestor chain; the edge that revisits a
+  // seen node is severed, rooting that page. Deterministic in input order.
+  for (const p of pages) {
+    const seen = new Set<string>([p.id])
+    let cur = p.id
+    for (;;) {
+      const parent = parentOf.get(cur) ?? null
+      if (parent === null) break
+      if (seen.has(parent)) {
+        parentOf.set(cur, null)
+        break
+      }
+      seen.add(parent)
+      cur = parent
+    }
+  }
+
+  const nodeById = new Map<string, PageTreeNode>()
+  for (const p of pages) nodeById.set(p.id, { page: p, children: [] })
+
+  const roots: PageTreeNode[] = []
+  for (const p of pages) {
+    const node = nodeById.get(p.id)!
+    const parentId = parentOf.get(p.id) ?? null
+    const parentNode = parentId !== null ? nodeById.get(parentId) : undefined
+    if (parentNode) parentNode.children.push(node)
+    else roots.push(node)
+  }
+
+  const sortRecursive = (nodes: PageTreeNode[]) => {
+    nodes.sort(compareSiblings)
+    for (const n of nodes) sortRecursive(n.children)
+  }
+  sortRecursive(roots)
+  return roots
+}
+
+/**
+ * Flatten the tree into visible rows: children render only when their
+ * parent's id is in `expanded`.
+ */
+export function flattenPageTree(nodes: PageTreeNode[], expanded: Set<string>): PageTreeRow[] {
+  const rows: PageTreeRow[] = []
+  const walk = (list: PageTreeNode[], depth: number) => {
+    for (const node of list) {
+      const hasChildren = node.children.length > 0
+      rows.push({ page: node.page, depth, hasChildren })
+      if (hasChildren && expanded.has(node.page.id)) walk(node.children, depth + 1)
+    }
+  }
+  walk(nodes, 0)
+  return rows
+}
+
+/** Default expand state: every root node that has children starts open. */
+export function defaultExpandedIds(roots: PageTreeNode[]): Set<string> {
+  return new Set(roots.filter((n) => n.children.length > 0).map((n) => n.page.id))
+}

package/src/lib/posts-service.ts

@@ -50,6 +50,8 @@ export interface Post {
   publishDate: string | null
   updatedDate: string
   seoScore: number | null
+  /** Featured-image URL for the list thumbnail, when the document has one. */
+  imageUrl: string | null
   createdAt: string
   updatedAt: string
 }
@@ -151,6 +153,7 @@ interface PostsApiPost {
   createdAt: string
   updatedAt: string
   seoScore: number | null
+  image?: string | null
   author: { id: string; name: string } | null
 }
 
@@ -240,6 +243,7 @@ export async function fetchPosts(query: PostsQuery = {}): Promise<PostsResult> {
       publishDate: d.publishedAt ?? d.scheduledAt ?? null,
       updatedDate: pickDisplayDate(d),
       seoScore: d.seoScore,
+      imageUrl: d.image ?? null,
       createdAt: d.createdAt,
       updatedAt: d.updatedAt,
     }
@@ -282,6 +286,28 @@ export async function bulkUpdatePosts(
   return { ok, failed }
 }
 
+/** Duplicate a single post. Server resets status to DRAFT and appends "(Copy)". */
+export async function duplicatePost(
+  postTypeId: string,
+  id: string,
+): Promise<{ id?: string; error?: string }> {
+  const res = await cmsApi<{ id?: string }>(
+    `/collections/${encodeURIComponent(postTypeId)}/${encodeURIComponent(id)}/duplicate`,
+    { method: 'POST' },
+  )
+  if (res.error) return { error: res.error }
+  return { id: res.data?.id }
+}
+
+/** Soft-delete a single post. */
+export async function deletePost(postTypeId: string, id: string): Promise<{ error?: string }> {
+  const res = await cmsApi(
+    `/collections/${encodeURIComponent(postTypeId)}/${encodeURIComponent(id)}`,
+    { method: 'DELETE' },
+  )
+  return res.error ? { error: res.error } : {}
+}
+
 export async function bulkDeletePosts(
   ids: Array<{ postTypeId: string; id: string }>,
 ): Promise<{ ok: number; failed: number }> {

package/src/lib/seo-service.ts

@@ -635,6 +635,9 @@ export interface CrawlSettings {
   indexEntireSite: boolean
   includeImagesInSitemap: boolean
   includePostsInSitemap: boolean
+  sitemapEnabled: boolean
+  autoRegenerateSitemapOnPublish: boolean
+  pingSearchEnginesOnPublish: boolean
 }
 
 export async function fetchSitemapStatus(): Promise<SitemapStatus | null> {