@actuate-media/cms-admin 0.14.1 → 0.16.0

package/src/__tests__/layout/sidebar-posts.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, it } from 'vitest'
+import { buildNavItems } from '../../layout/Sidebar.js'
+
+/**
+ * Regression coverage for the Posts area sidebar grouping.
+ *
+ * The reference design shows a single "Posts" parent with two fixed
+ * children — All Posts and Post Types — even when the config defines
+ * multiple post-type collections (Blog, Case Studies, News, ...). That
+ * collapsing is fragile (it's tempting to enumerate each collection
+ * as its own sidebar entry) so we lock the contract with explicit
+ * tests.
+ */
+
+describe('buildNavItems', () => {
+  it('returns the default tree when no collections are provided', () => {
+    const items = buildNavItems({})
+    const posts = items.find((i) => i.path === '/posts')
+    expect(posts).toBeDefined()
+    expect(posts?.children?.map((c) => c.path)).toEqual(['/posts', '/posts/types'])
+    // Pages no longer carries children — Saved Sections / Templates moved
+    // under the dedicated Templates parent.
+    const pages = items.find((i) => i.path === '/pages')
+    expect(pages?.children ?? []).toEqual([])
+    // Templates is its own item with Saved Sections + Widgets.
+    const templates = items.find((i) => i.path === '/page-templates')
+    expect(templates?.children?.map((c) => c.path)).toEqual(['/saved-sections', '/widgets'])
+  })
+
+  it('exposes Templates as a top-level Content item with Saved Sections + Widgets', () => {
+    const items = buildNavItems({
+      collections: {
+        pages: { slug: 'pages', labels: { singular: 'Page', plural: 'Pages' }, type: 'page' },
+      },
+    })
+    const templates = items.find((i) => i.path === '/page-templates')
+    expect(templates).toBeDefined()
+    expect(templates?.group).toBe('Content')
+    expect(templates?.children?.map((c) => c.label)).toEqual(['Saved Sections', 'Widgets'])
+    // Templates is NOT nested under Pages.
+    const pages = items.find((i) => i.path === '/pages')
+    expect(pages?.children ?? []).toEqual([])
+  })
+
+  it('collapses every type:post collection under a single Posts parent', () => {
+    const items = buildNavItems({
+      collections: {
+        blog: { slug: 'blog', labels: { singular: 'Blog Post', plural: 'Blog' }, type: 'post' },
+        'case-studies': {
+          slug: 'case-studies',
+          labels: { singular: 'Case Study', plural: 'Case Studies' },
+          type: 'post',
+        },
+        news: { slug: 'news', labels: { singular: 'News Item', plural: 'News' }, type: 'post' },
+        pages: { slug: 'pages', labels: { singular: 'Page', plural: 'Pages' }, type: 'page' },
+      },
+    })
+
+    // Exactly one /posts entry, regardless of how many post types exist.
+    const postEntries = items.filter((i) => i.path === '/posts')
+    expect(postEntries).toHaveLength(1)
+
+    // Children are still the fixed pair — the per-type collections
+    // are NOT enumerated as sidebar siblings.
+    const children = postEntries[0]?.children?.map((c) => c.path)
+    expect(children).toEqual(['/posts', '/posts/types'])
+
+    // No per-type slug ended up as a top-level sidebar item.
+    const slugPaths = items.map((i) => i.path)
+    for (const slug of ['blog', 'case-studies', 'news']) {
+      expect(slugPaths).not.toContain(`/${slug}`)
+    }
+  })
+
+  it('treats admin.group=Posts (case-insensitive) as a synonym for type=post', () => {
+    const items = buildNavItems({
+      collections: {
+        reviews: {
+          slug: 'reviews',
+          labels: { singular: 'Review', plural: 'Reviews' },
+          // Intentionally NOT type:'post' — relying on the group marker.
+          admin: { group: 'posts' },
+        },
+      },
+    })
+    expect(items.some((i) => i.path === '/posts')).toBe(true)
+    expect(items.some((i) => i.path === '/reviews')).toBe(false)
+  })
+
+  it('omits the Posts parent entirely when no post-type collections exist', () => {
+    const items = buildNavItems({
+      collections: {
+        pages: { slug: 'pages', labels: { singular: 'Page', plural: 'Pages' }, type: 'page' },
+      },
+    })
+    expect(items.some((i) => i.path === '/posts')).toBe(false)
+  })
+
+  it('places Pages above Posts, both under the CONTENT group', () => {
+    const items = buildNavItems({
+      collections: {
+        blog: { slug: 'blog', labels: { singular: 'Blog Post', plural: 'Blog' }, type: 'post' },
+        pages: { slug: 'pages', labels: { singular: 'Page', plural: 'Pages' }, type: 'page' },
+      },
+    })
+
+    const pagesIdx = items.findIndex((i) => i.path === '/pages')
+    const postsIdx = items.findIndex((i) => i.path === '/posts')
+    const mediaIdx = items.findIndex((i) => i.path === '/media')
+
+    // Pages comes before Posts, and both come before the static
+    // content destinations.
+    expect(pagesIdx).toBeGreaterThanOrEqual(0)
+    expect(pagesIdx).toBeLessThan(postsIdx)
+    expect(postsIdx).toBeLessThan(mediaIdx)
+
+    // Both are tagged Content so the single CONTENT header sits above
+    // Pages (the first Content item in the tree).
+    expect(items[pagesIdx]?.group).toBe('Content')
+    expect(items[postsIdx]?.group).toBe('Content')
+
+    // The first item carrying group 'Content' is Pages — i.e. the
+    // CONTENT header renders directly above it.
+    const firstContent = items.find((i) => i.group === 'Content')
+    expect(firstContent?.path).toBe('/pages')
+  })
+
+  it('defaults: Pages is the first CONTENT item, above Posts', () => {
+    const items = buildNavItems({})
+    const pagesIdx = items.findIndex((i) => i.path === '/pages')
+    const postsIdx = items.findIndex((i) => i.path === '/posts')
+    expect(items[pagesIdx]?.group).toBe('Content')
+    expect(items[postsIdx]?.group).toBe('Content')
+    expect(pagesIdx).toBeLessThan(postsIdx)
+    expect(items.find((i) => i.group === 'Content')?.path).toBe('/pages')
+  })
+
+  it('renders an admin.group=Content collection (Menus) as its own Content item', () => {
+    const items = buildNavItems({
+      collections: {
+        pages: { slug: 'pages', labels: { singular: 'Page', plural: 'Pages' }, type: 'page' },
+        navigations: {
+          slug: 'navigations',
+          labels: { singular: 'Menu', plural: 'Menus' },
+          admin: { group: 'Content', icon: 'navigation' },
+        },
+      },
+    })
+
+    const menus = items.find((i) => i.path === '/navigations')
+    expect(menus).toBeDefined()
+    expect(menus?.label).toBe('Menus')
+    expect(menus?.group).toBe('Content')
+    // It is a flat Content entry, not a child of Posts/Templates/Pages.
+    expect(menus?.children).toBeUndefined()
+    // Lands after the static Content destinations, before Settings.
+    const menusIdx = items.findIndex((i) => i.path === '/navigations')
+    const scriptIdx = items.findIndex((i) => i.path === '/script-tags')
+    const usersIdx = items.findIndex((i) => i.path === '/users')
+    expect(menusIdx).toBeGreaterThan(scriptIdx)
+    expect(menusIdx).toBeLessThan(usersIdx)
+  })
+
+  it('keeps standard Content/Settings entries after collections', () => {
+    const items = buildNavItems({
+      collections: {
+        blog: { slug: 'blog', labels: { singular: 'Blog Post', plural: 'Blog' }, type: 'post' },
+      },
+    })
+    const paths = items.map((i) => i.path)
+    expect(paths).toContain('/media')
+    expect(paths).toContain('/forms')
+    expect(paths).toContain('/seo')
+    expect(paths).toContain('/script-tags')
+    expect(paths).toContain('/users')
+    expect(paths).toContain('/api-keys')
+    expect(paths).toContain('/settings')
+  })
+})

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

@@ -0,0 +1,173 @@
+import { describe, expect, it } from 'vitest'
+import {
+  addSection,
+  createSection,
+  duplicateSection,
+  emptyPage,
+  moveSection,
+  removeSection,
+  reorderSections,
+  toggleSectionVisibility,
+  updateSectionContent,
+  updateSectionMeta,
+  updateSectionSettings,
+  validatePage,
+  type EditorPage,
+  type PageSection,
+} from '../../lib/page-editor-service.js'
+import { SECTION_TYPES, SECTION_TYPE_LIST } from '../../views/page-editor/section-types.js'
+
+function basePage(sections: PageSection[]): EditorPage {
+  return { ...emptyPage(), title: 'About', slug: 'about', path: '/about', sections }
+}
+
+describe('createSection', () => {
+  it('seeds content + settings from the registry and a unique id', () => {
+    const a = createSection('hero')
+    const b = createSection('hero')
+    expect(a.sectionType).toBe('hero')
+    expect(a.name).toBe(SECTION_TYPES.hero.name)
+    expect(a.visible).toBe(true)
+    expect(a.id).not.toBe(b.id)
+    expect(a.content.heading).toBe(SECTION_TYPES.hero.defaultContent.heading)
+  })
+
+  it('deep-clones defaults so sections never share references', () => {
+    const a = createSection('stats')
+    const b = createSection('stats')
+    ;(a.content.stats as unknown[]).push({ value: 'x' })
+    expect((b.content.stats as unknown[]).length).toBe(
+      (SECTION_TYPES.stats.defaultContent.stats as unknown[]).length,
+    )
+  })
+})
+
+describe('section array helpers', () => {
+  const s1 = createSection('hero')
+  const s2 = createSection('text')
+  const s3 = createSection('cta')
+  const list = [s1, s2, s3]
+
+  it('addSection appends by default and inserts at an index', () => {
+    const extra = createSection('stats')
+    expect(addSection(list, extra).map((s) => s.id)).toEqual([s1.id, s2.id, s3.id, extra.id])
+    expect(addSection(list, extra, 1).map((s) => s.id)).toEqual([s1.id, extra.id, s2.id, s3.id])
+  })
+
+  it('removeSection drops the matching id', () => {
+    expect(removeSection(list, s2.id).map((s) => s.id)).toEqual([s1.id, s3.id])
+  })
+
+  it('moveSection relocates and clamps', () => {
+    expect(moveSection(list, s1.id, 2).map((s) => s.id)).toEqual([s2.id, s3.id, s1.id])
+    expect(moveSection(list, s1.id, 99).map((s) => s.id)).toEqual([s2.id, s3.id, s1.id])
+  })
+
+  it('reorderSections respects explicit order and never drops sections', () => {
+    expect(reorderSections(list, [s3.id, s1.id, s2.id]).map((s) => s.id)).toEqual([
+      s3.id,
+      s1.id,
+      s2.id,
+    ])
+    // missing ids are appended defensively rather than lost
+    expect(reorderSections(list, [s2.id]).map((s) => s.id)).toEqual([s2.id, s1.id, s3.id])
+  })
+
+  it('duplicateSection inserts a new-id copy right after the original', () => {
+    const out = duplicateSection(list, s2.id)
+    expect(out).toHaveLength(4)
+    expect(out[2]!.id).not.toBe(s2.id)
+    expect(out[2]!.name).toBe(`${s2.name} (Copy)`)
+    expect(out[2]!.sectionType).toBe(s2.sectionType)
+  })
+
+  it('toggleSectionVisibility flips only the target', () => {
+    const out = toggleSectionVisibility(list, s1.id)
+    expect(out.find((s) => s.id === s1.id)!.visible).toBe(false)
+    expect(out.find((s) => s.id === s2.id)!.visible).toBe(true)
+  })
+
+  it('updateSectionContent / settings / meta patch immutably', () => {
+    const c = updateSectionContent(list, s1.id, { heading: 'New' })
+    expect(c.find((s) => s.id === s1.id)!.content.heading).toBe('New')
+    expect(list.find((s) => s.id === s1.id)!.content.heading).not.toBe('New')
+
+    const st = updateSectionSettings(list, s1.id, { paddingY: 'sm' })
+    expect(st.find((s) => s.id === s1.id)!.settings.paddingY).toBe('sm')
+
+    const m = updateSectionMeta(list, s1.id, { name: 'Renamed' })
+    expect(m.find((s) => s.id === s1.id)!.name).toBe('Renamed')
+  })
+})
+
+describe('validatePage', () => {
+  it('requires title and path', () => {
+    const page = basePage([])
+    page.title = ''
+    page.path = ''
+    const { errors } = validatePage(page, false)
+    expect(errors).toContain('Page title is required.')
+    expect(errors).toContain('Page path is required.')
+  })
+
+  it('requires at least one visible section to publish', () => {
+    const hidden = { ...createSection('hero'), visible: false }
+    const { errors } = validatePage(basePage([hidden]), true)
+    expect(errors.some((e) => e.includes('at least one visible section'))).toBe(true)
+  })
+
+  it('flags missing required section fields on publish', () => {
+    const hero = createSection('hero')
+    hero.content.heading = '' // required
+    const { errors } = validatePage(basePage([hero]), true)
+    expect(errors.some((e) => e.includes('Heading'))).toBe(true)
+  })
+
+  it('flags invalid button URLs and missing image alt on publish', () => {
+    const feature = createSection('feature')
+    feature.content.heading = 'Has heading'
+    feature.content.buttonLabel = 'Learn more'
+    feature.content.buttonUrl = 'not a url'
+    feature.content.imageUrl = 'https://x/img.png'
+    feature.content.imageAlt = ''
+    const { errors } = validatePage(basePage([feature]), true)
+    expect(errors.some((e) => e.includes('not a valid URL'))).toBe(true)
+    expect(errors.some((e) => e.includes('alt text'))).toBe(true)
+  })
+
+  it('accepts a valid page and warns on missing SEO', () => {
+    const hero = createSection('hero')
+    const { errors, warnings } = validatePage(basePage([hero]), true)
+    expect(errors).toEqual([])
+    expect(warnings.length).toBeGreaterThan(0)
+  })
+
+  it('does not run publish-only rules for draft saves', () => {
+    const { errors } = validatePage(basePage([]), false)
+    expect(errors.some((e) => e.includes('visible section'))).toBe(false)
+  })
+})
+
+describe('section type registry', () => {
+  it('every listed type has a renderable id, defaults, fields, and a scope', () => {
+    const renderable = new Set([
+      'hero',
+      'text',
+      'feature',
+      'stats',
+      'cta',
+      'article-body',
+      'quote',
+      'author-bio',
+      'related-posts',
+      'gallery',
+    ])
+    expect(SECTION_TYPE_LIST.length).toBe(renderable.size)
+    for (const def of SECTION_TYPE_LIST) {
+      expect(renderable.has(def.id)).toBe(true)
+      expect(def.fields.length).toBeGreaterThan(0)
+      expect(def.defaultContent).toBeTruthy()
+      expect(def.scope.length).toBeGreaterThan(0)
+    }
+  })
+})

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

@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest'
+import { applyPagesQuery, groupPages, type Page, type PageTag } from '../../lib/pages-service.js'
+
+/**
+ * Unit coverage for the Pages filtering/grouping logic. These are the
+ * pure functions the PagesListView depends on — kept network-free so the
+ * search/tag/status/sort/group contracts are locked independent of the
+ * REST layer.
+ */
+
+function page(partial: Partial<Page> & Pick<Page, 'id' | 'title'>): Page {
+  return {
+    id: partial.id,
+    title: partial.title,
+    path: partial.path ?? `/${partial.title.toLowerCase()}`,
+    slug: partial.slug ?? partial.title.toLowerCase(),
+    parentPageId: null,
+    tags: partial.tags ?? [],
+    primaryTagId: partial.primaryTagId ?? partial.tags?.[0] ?? null,
+    authorId: partial.authorId ?? 'u1',
+    authorName: partial.authorName ?? 'Maria K.',
+    authorInitials: 'MK',
+    status: partial.status ?? 'PUBLISHED',
+    publishDate: null,
+    scheduledDate: null,
+    lastModified: partial.lastModified ?? '2026-05-01',
+    seoScore: partial.seoScore ?? null,
+    seoTitle: null,
+    seoDescription: null,
+    templateId: null,
+    isHomepage: partial.isHomepage ?? false,
+    isSystemPage: false,
+    createdAt: '2026-01-01',
+    updatedAt: partial.lastModified ?? '2026-05-01',
+  }
+}
+
+const TAGS: PageTag[] = [
+  {
+    id: 'core',
+    docId: 'd1',
+    name: 'Core',
+    slug: 'core',
+    description: null,
+    color: 'purple',
+    pageCount: 0,
+    sortOrder: 0,
+    active: true,
+    createdAt: null,
+    updatedAt: null,
+  },
+  {
+    id: 'services',
+    docId: 'd2',
+    name: 'Services',
+    slug: 'services',
+    description: null,
+    color: 'green',
+    pageCount: 0,
+    sortOrder: 1,
+    active: true,
+    createdAt: null,
+    updatedAt: null,
+  },
+]
+
+const PAGES: Page[] = [
+  page({ id: '1', title: 'About', tags: ['core'], status: 'PUBLISHED', seoScore: 88 }),
+  page({
+    id: '2',
+    title: 'Services',
+    tags: ['core', 'services'],
+    status: 'PUBLISHED',
+    seoScore: 85,
+  }),
+  page({
+    id: '3',
+    title: 'SEO Services',
+    tags: ['services'],
+    status: 'DRAFT',
+    seoScore: 44,
+    authorId: 'u2',
+    authorName: 'Sarah M.',
+  }),
+  page({ id: '4', title: 'Home', tags: [], status: 'PUBLISHED', isHomepage: true, seoScore: 92 }),
+]
+
+describe('applyPagesQuery', () => {
+  it('defaults to title ascending', () => {
+    const out = applyPagesQuery(PAGES, {})
+    expect(out.map((p) => p.title)).toEqual(['About', 'Home', 'SEO Services', 'Services'])
+  })
+
+  it('filters by status', () => {
+    const out = applyPagesQuery(PAGES, { status: 'DRAFT' })
+    expect(out.map((p) => p.id)).toEqual(['3'])
+  })
+
+  it('filters by tag with OR semantics', () => {
+    const out = applyPagesQuery(PAGES, { tagIds: ['services'] })
+    expect(out.map((p) => p.id).sort()).toEqual(['2', '3'])
+  })
+
+  it('matches multiple selected tags (union)', () => {
+    const out = applyPagesQuery(PAGES, { tagIds: ['core', 'services'] })
+    expect(out.map((p) => p.id).sort()).toEqual(['1', '2', '3'])
+  })
+
+  it('searches title, path, and tags', () => {
+    expect(applyPagesQuery(PAGES, { search: 'seo' }).map((p) => p.id)).toEqual(['3'])
+    expect(
+      applyPagesQuery(PAGES, { search: 'core' })
+        .map((p) => p.id)
+        .sort(),
+    ).toEqual(['1', '2'])
+  })
+
+  it('sorts by seo descending', () => {
+    const out = applyPagesQuery(PAGES, { sortBy: 'seo', sortDirection: 'desc' })
+    expect(out[0]?.id).toBe('4') // Home, 92
+  })
+})
+
+describe('groupPages', () => {
+  it('returns a single bucket for groupBy none', () => {
+    const groups = groupPages(PAGES, 'none', TAGS)
+    expect(groups).toHaveLength(1)
+    expect(groups[0]?.pages).toHaveLength(4)
+  })
+
+  it('groups by primary tag and bucket-labels untagged pages', () => {
+    const groups = groupPages(PAGES, 'tag', TAGS)
+    const byKey = new Map(groups.map((g) => [g.key, g]))
+    // About + Services have primary tag 'core'; SEO Services 'services';
+    // Home has no tags → Untagged.
+    expect(
+      byKey
+        .get('core')
+        ?.pages.map((p) => p.id)
+        .sort(),
+    ).toEqual(['1', '2'])
+    expect(byKey.get('services')?.pages.map((p) => p.id)).toEqual(['3'])
+    expect(byKey.get('__untagged')?.pages.map((p) => p.id)).toEqual(['4'])
+  })
+
+  it('never duplicates a page across tag groups', () => {
+    const groups = groupPages(PAGES, 'tag', TAGS)
+    const total = groups.reduce((n, g) => n + g.pages.length, 0)
+    expect(total).toBe(PAGES.length)
+  })
+
+  it('groups by status', () => {
+    const groups = groupPages(PAGES, 'status', TAGS)
+    const published = groups.find((g) => g.key === 'PUBLISHED')
+    expect(published?.pages).toHaveLength(3)
+  })
+})