@actuate-media/cms-admin 0.15.0 → 0.16.1

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)
+  })
+})

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

@@ -0,0 +1,215 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+// `cmsApi` is the only I/O dependency; mock it so the service is tested
+// hermetically. Responses follow the SDK `{ data, error }` envelope.
+const cmsApiMock = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApiMock(...args),
+}))
+
+const {
+  validatePost,
+  validateTemplate,
+  emptyPostFromTemplate,
+  fetchTemplateForEditor,
+  savePostDraft,
+} = await import('../../lib/post-editor-service.js')
+
+type EditorPostT = Awaited<ReturnType<typeof emptyPostFromTemplate>>
+
+function basePost(over: Partial<EditorPostT> = {}): EditorPostT {
+  return {
+    id: 'p1',
+    postType: 'blog',
+    title: 'Hello',
+    slug: 'hello',
+    excerpt: '',
+    featuredImage: '',
+    body: '',
+    category: '',
+    status: 'DRAFT',
+    publishDate: null,
+    sections: [],
+    seoTitle: '',
+    seoDescription: '',
+    publishedAt: null,
+    updatedAt: null,
+    ...over,
+  }
+}
+
+beforeEach(() => {
+  cmsApiMock.mockReset()
+})
+
+describe('validatePost', () => {
+  it('requires title + slug', () => {
+    const r = validatePost(basePost({ title: '', slug: '' }), false)
+    expect(r.errors).toContain('Post title is required.')
+    expect(r.errors).toContain('Post slug is required.')
+  })
+
+  it('does not run section validation for draft saves', () => {
+    const r = validatePost(
+      basePost({
+        sections: [
+          {
+            id: 's1',
+            sectionType: 'quote',
+            name: 'Quote',
+            visible: true,
+            content: {},
+            settings: {},
+          },
+        ],
+      }),
+      false,
+    )
+    expect(r.errors).toEqual([])
+  })
+
+  it('runs section + SEO checks at publish time', () => {
+    const r = validatePost(
+      basePost({
+        sections: [
+          // missing required `quote` field → blocking section error
+          {
+            id: 's1',
+            sectionType: 'quote',
+            name: 'Quote',
+            visible: true,
+            content: {},
+            settings: {},
+          },
+        ],
+      }),
+      true,
+    )
+    expect(r.errors.some((e) => e.startsWith('Quote:'))).toBe(true)
+    expect(r.warnings.some((w) => w.includes('SEO title'))).toBe(true)
+  })
+
+  it('skips hidden sections during publish validation', () => {
+    const r = validatePost(
+      basePost({
+        seoTitle: 'T',
+        seoDescription: 'D',
+        sections: [
+          {
+            id: 's1',
+            sectionType: 'quote',
+            name: 'Quote',
+            visible: false,
+            content: {},
+            settings: {},
+          },
+        ],
+      }),
+      true,
+    )
+    expect(r.errors).toEqual([])
+  })
+})
+
+describe('validateTemplate', () => {
+  it('validates only visible section content', () => {
+    const r = validateTemplate({
+      docId: null,
+      postType: 'blog',
+      header: {
+        layout: 'centered',
+        showFeaturedImage: true,
+        showExcerpt: true,
+        showAuthor: true,
+        showDate: true,
+        showCategory: true,
+        showReadingTime: false,
+      },
+      sections: [
+        { id: 's1', sectionType: 'quote', name: 'Quote', visible: true, content: {}, settings: {} },
+      ],
+    })
+    expect(r.errors.some((e) => e.startsWith('Quote:'))).toBe(true)
+  })
+})
+
+describe('emptyPostFromTemplate', () => {
+  it('seeds sections from the type template with fresh ids', async () => {
+    // fetchTemplateForEditor lists the post-templates collection.
+    cmsApiMock.mockResolvedValueOnce({
+      data: {
+        docs: [
+          {
+            id: 'tmpl-1',
+            slug: 'blog',
+            data: {
+              header: { layout: 'left' },
+              sections: [
+                {
+                  id: 'orig',
+                  sectionType: 'article-body',
+                  name: 'Body',
+                  visible: true,
+                  content: {},
+                  settings: {},
+                },
+              ],
+            },
+          },
+        ],
+      },
+    })
+    const post = await emptyPostFromTemplate('blog')
+    expect(post.id).toBeNull()
+    expect(post.postType).toBe('blog')
+    expect(post.sections).toHaveLength(1)
+    expect(post.sections[0]!.sectionType).toBe('article-body')
+    // cloned: a fresh id, not the template's section id
+    expect(post.sections[0]!.id).not.toBe('orig')
+  })
+
+  it('starts empty when the type has no template', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: { docs: [] } })
+    const post = await emptyPostFromTemplate('news')
+    expect(post.sections).toEqual([])
+  })
+})
+
+describe('fetchTemplateForEditor', () => {
+  it('returns an unsaved default when no template document matches', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: { docs: [] } })
+    const t = await fetchTemplateForEditor('blog')
+    expect(t.docId).toBeNull()
+    expect(t.header.layout).toBe('centered')
+    expect(t.sections).toEqual([])
+  })
+})
+
+describe('savePostDraft', () => {
+  it('PUTs the post fields + sections for an existing post', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: { id: 'p1', title: 'Hello', slug: 'hello', status: 'DRAFT', data: { sections: [] } },
+    })
+    await savePostDraft(basePost({ body: 'Body copy', category: 'News' }))
+    expect(cmsApiMock).toHaveBeenCalledTimes(1)
+    const [endpoint, init] = cmsApiMock.mock.calls[0]!
+    expect(endpoint).toBe('/collections/blog/p1')
+    expect(init.method).toBe('PUT')
+    const body = JSON.parse(init.body as string)
+    expect(body.title).toBe('Hello')
+    expect(body.body).toBe('Body copy')
+    expect(body.category).toBe('News')
+    expect(Array.isArray(body.sections)).toBe(true)
+  })
+
+  it('POSTs to create when the post has no id', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: { id: 'new1', title: 'Hello', slug: 'hello', status: 'DRAFT', data: {} },
+    })
+    const out = await savePostDraft(basePost({ id: null }))
+    const [endpoint, init] = cmsApiMock.mock.calls[0]!
+    expect(endpoint).toBe('/collections/blog')
+    expect(init.method).toBe('POST')
+    expect(out.id).toBe('new1')
+  })
+})