@actuate-media/cms-admin 0.17.0 → 0.19.0

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

@@ -0,0 +1,160 @@
+// @vitest-environment node
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const cmsApi = vi.fn()
+vi.mock('../../lib/api.js', () => ({
+  cmsApi: (...args: unknown[]) => cmsApi(...args),
+}))
+
+const { fetchPages, fetchPagesDataset, bulkUpdatePages, bulkChangePageTags } =
+  await import('../../lib/pages-service.js')
+
+afterEach(() => {
+  cmsApi.mockReset()
+})
+
+function pageDoc(
+  id: string,
+  over: Record<string, unknown> = {},
+  data: Record<string, unknown> = {},
+) {
+  return {
+    id,
+    collection: 'pages',
+    title: id,
+    slug: id,
+    status: 'PUBLISHED',
+    createdById: 'u1',
+    updatedById: 'u1',
+    publishedAt: '2026-01-01T00:00:00Z',
+    scheduledAt: null,
+    createdAt: '2026-01-01T00:00:00Z',
+    updatedAt: '2026-01-01T00:00:00Z',
+    data: { path: `/${id}`, ...data },
+    ...over,
+  }
+}
+
+// Route the three reads fetchPagesDataset performs (users, tags, pages).
+function routeReads(pages: unknown[], tags: unknown[] = []) {
+  cmsApi.mockImplementation((endpoint: string) => {
+    if (endpoint.startsWith('/users')) {
+      return Promise.resolve({
+        data: { users: [{ id: 'u1', name: 'Jane Doe', email: 'jane@example.com' }] },
+        status: 200,
+      })
+    }
+    if (endpoint.startsWith('/collections/page-tags')) {
+      return Promise.resolve({ data: { docs: tags, total: tags.length }, status: 200 })
+    }
+    if (endpoint.startsWith('/collections/pages')) {
+      return Promise.resolve({ data: { docs: pages, total: pages.length }, status: 200 })
+    }
+    return Promise.resolve({ data: null, status: 200 })
+  })
+}
+
+describe('fetchPagesDataset', () => {
+  it('returns every page plus tag counts derived from the full set', async () => {
+    routeReads(
+      [
+        pageDoc('p1', { status: 'DRAFT' }, { tags: ['a'] }),
+        pageDoc('p2', {}, { tags: ['a', 'b'] }),
+        pageDoc('p3'), // untagged
+      ],
+      [
+        { id: 't1', slug: 'a', title: 'Alpha', data: { color: 'green', sortOrder: 0 } },
+        { id: 't2', slug: 'b', title: 'Beta', data: { sortOrder: 1 } },
+      ],
+    )
+
+    const ds = await fetchPagesDataset()
+    expect(ds.pages).toHaveLength(3)
+    expect(ds.tags.find((t) => t.slug === 'a')?.pageCount).toBe(2)
+    expect(ds.tags.find((t) => t.slug === 'b')?.pageCount).toBe(1)
+    expect(ds.authors).toHaveLength(1)
+  })
+})
+
+describe('fetchPages counts', () => {
+  it('reports grandTotal as the unfiltered count, independent of tag membership', async () => {
+    // p3 is untagged: a tag-sum total would undercount (the I-1 bug). The
+    // grandTotal must reflect all three pages.
+    routeReads(
+      [pageDoc('p1', {}, { tags: ['a'] }), pageDoc('p2', {}, { tags: ['a'] }), pageDoc('p3')],
+      [{ id: 't1', slug: 'a', title: 'Alpha', data: {} }],
+    )
+
+    const res = await fetchPages()
+    expect(res.grandTotal).toBe(3)
+    expect(res.total).toBe(3)
+  })
+
+  it('paginates the flat view and keeps total/grandTotal stable', async () => {
+    routeReads([pageDoc('p1'), pageDoc('p2'), pageDoc('p3')])
+
+    const first = await fetchPages({ page: 1, pageSize: 2 })
+    expect(first.pages).toHaveLength(2)
+    expect(first.total).toBe(3)
+    expect(first.grandTotal).toBe(3)
+
+    const second = await fetchPages({ page: 2, pageSize: 2 })
+    expect(second.pages).toHaveLength(1)
+    expect(second.total).toBe(3)
+    expect(second.grandTotal).toBe(3)
+  })
+
+  it('total reflects the filter while grandTotal does not', async () => {
+    routeReads([
+      pageDoc('p1', { status: 'DRAFT' }),
+      pageDoc('p2', { status: 'PUBLISHED' }),
+      pageDoc('p3', { status: 'PUBLISHED' }),
+    ])
+
+    const res = await fetchPages({ status: 'DRAFT' })
+    expect(res.total).toBe(1)
+    expect(res.grandTotal).toBe(3)
+  })
+})
+
+describe('bulk operations', () => {
+  it('counts ok/failed across a batch and issues one request per id', async () => {
+    cmsApi.mockImplementation((endpoint: string) =>
+      Promise.resolve(
+        endpoint.includes('bad') ? { error: 'nope', status: 500 } : { data: {}, status: 200 },
+      ),
+    )
+
+    const result = await bulkUpdatePages(['a', 'bad', 'c'], { status: 'PUBLISHED' })
+    expect(result).toEqual({ ok: 2, failed: 1 })
+    expect(cmsApi).toHaveBeenCalledTimes(3)
+  })
+
+  it('does not drop or double-process work above the concurrency limit', async () => {
+    cmsApi.mockResolvedValue({ data: {}, status: 200 })
+    const ids = Array.from({ length: 12 }, (_, i) => `p${i}`)
+    const result = await bulkUpdatePages(ids, { status: 'DRAFT' })
+    expect(result).toEqual({ ok: 12, failed: 0 })
+    expect(cmsApi).toHaveBeenCalledTimes(12)
+  })
+
+  it('treats a thrown request as a failure rather than aborting the batch', async () => {
+    let call = 0
+    cmsApi.mockImplementation(() => {
+      call++
+      if (call === 2) return Promise.reject(new Error('network'))
+      return Promise.resolve({ data: {}, status: 200 })
+    })
+
+    const result = await bulkChangePageTags(
+      [
+        { id: 'a', tags: [], primaryTagId: null },
+        { id: 'b', tags: [], primaryTagId: null },
+        { id: 'c', tags: [], primaryTagId: null },
+      ],
+      { add: ['x'] },
+    )
+    expect(result.ok).toBe(2)
+    expect(result.failed).toBe(1)
+  })
+})

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

@@ -135,26 +135,21 @@ describe('validateTemplate', () => {
 
 describe('emptyPostFromTemplate', () => {
   it('seeds sections from the type template with fresh ids', async () => {
-    // fetchTemplateForEditor lists the post-templates collection.
+    // fetchTemplateForEditor reads the dedicated /post-templates/:type endpoint,
+    // whose `{ data }` envelope is unwrapped by cmsApi to { postType, docId, header, sections }.
     cmsApiMock.mockResolvedValueOnce({
       data: {
-        docs: [
+        postType: 'blog',
+        docId: 'tmpl-1',
+        header: { layout: 'left' },
+        sections: [
           {
-            id: 'tmpl-1',
-            slug: 'blog',
-            data: {
-              header: { layout: 'left' },
-              sections: [
-                {
-                  id: 'orig',
-                  sectionType: 'article-body',
-                  name: 'Body',
-                  visible: true,
-                  content: {},
-                  settings: {},
-                },
-              ],
-            },
+            id: 'orig',
+            sectionType: 'article-body',
+            name: 'Body',
+            visible: true,
+            content: {},
+            settings: {},
           },
         ],
       },
@@ -166,22 +161,82 @@ describe('emptyPostFromTemplate', () => {
     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')
+    // the endpoint was addressed by post type, not the raw collection API
+    expect(cmsApiMock.mock.calls[0]![0]).toBe('/post-templates/blog')
   })
 
-  it('starts empty when the type has no template', async () => {
-    cmsApiMock.mockResolvedValueOnce({ data: { docs: [] } })
+  it('seeds the default starting template when the type has no saved template', async () => {
+    // Unsaved type → endpoint returns docId null + empty sections; the service
+    // backfills the default (article-body + related-posts) so the post is never blank.
+    cmsApiMock.mockResolvedValueOnce({ data: { postType: 'news', docId: null, sections: [] } })
     const post = await emptyPostFromTemplate('news')
-    expect(post.sections).toEqual([])
+    expect(post.sections.map((s) => s.sectionType)).toEqual(['article-body', 'related-posts'])
+    // cloned with fresh, distinct ids
+    expect(post.sections[0]!.id).not.toBe(post.sections[1]!.id)
   })
 })
 
 describe('fetchTemplateForEditor', () => {
-  it('returns an unsaved default when no template document matches', async () => {
-    cmsApiMock.mockResolvedValueOnce({ data: { docs: [] } })
+  it('maps a saved template from the dedicated endpoint', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: {
+        postType: 'blog',
+        docId: 'tmpl-9',
+        header: { layout: 'overlay' },
+        sections: [
+          { id: 's1', sectionType: 'quote', name: 'Q', visible: true, content: {}, settings: {} },
+        ],
+      },
+    })
+    const t = await fetchTemplateForEditor('blog')
+    expect(t.docId).toBe('tmpl-9')
+    expect(t.header.layout).toBe('overlay')
+    expect(t.sections).toHaveLength(1)
+  })
+
+  it('seeds the default starting template when the type has no saved template', async () => {
+    cmsApiMock.mockResolvedValueOnce({ data: { postType: 'blog', docId: null, sections: [] } })
     const t = await fetchTemplateForEditor('blog')
     expect(t.docId).toBeNull()
     expect(t.header.layout).toBe('centered')
-    expect(t.sections).toEqual([])
+    expect(t.sections.map((s) => s.sectionType)).toEqual(['article-body', 'related-posts'])
+  })
+
+  it('falls back to the default template when the request fails', async () => {
+    cmsApiMock.mockResolvedValueOnce({ error: 'network down' })
+    const t = await fetchTemplateForEditor('blog')
+    expect(t.docId).toBeNull()
+    expect(t.sections.map((s) => s.sectionType)).toEqual(['article-body', 'related-posts'])
+  })
+})
+
+describe('saveTemplate', () => {
+  it('PUTs header + sections to the dedicated endpoint', async () => {
+    cmsApiMock.mockResolvedValueOnce({
+      data: { postType: 'blog', docId: 'tmpl-1', header: { layout: 'left' }, sections: [] },
+    })
+    const { saveTemplate } = await import('../../lib/post-editor-service.js')
+    const out = await saveTemplate({
+      docId: null,
+      postType: 'blog',
+      header: {
+        layout: 'left',
+        showFeaturedImage: true,
+        showExcerpt: true,
+        showAuthor: true,
+        showDate: true,
+        showCategory: true,
+        showReadingTime: false,
+      },
+      sections: [],
+    })
+    const [endpoint, init] = cmsApiMock.mock.calls[0]!
+    expect(endpoint).toBe('/post-templates/blog')
+    expect(init.method).toBe('PUT')
+    const body = JSON.parse(init.body as string)
+    expect(body.header.layout).toBe('left')
+    expect(Array.isArray(body.sections)).toBe(true)
+    expect(out.docId).toBe('tmpl-1')
   })
 })
 

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

@@ -10,37 +10,6 @@ vi.mock('../../lib/api.js', () => ({
 
 const { fetchPosts, fetchPostTypes } = await import('../../lib/posts-service.js')
 
-interface DocFixture {
-  id: string
-  collection: string
-  title: string
-  slug: string
-  status: 'PUBLISHED' | 'DRAFT' | 'SCHEDULED'
-  createdById: string
-  updatedById: string
-  publishedAt: string | null
-  scheduledAt: string | null
-  createdAt: string
-  updatedAt: string
-  data: Record<string, unknown> | null
-}
-
-function doc(
-  o: Partial<DocFixture> & Pick<DocFixture, 'id' | 'collection' | 'title' | 'slug'>,
-): DocFixture {
-  return {
-    status: 'PUBLISHED',
-    createdById: 'u-david',
-    updatedById: 'u-david',
-    publishedAt: '2026-05-10T00:00:00.000Z',
-    scheduledAt: null,
-    createdAt: '2026-05-10T00:00:00.000Z',
-    updatedAt: '2026-05-10T00:00:00.000Z',
-    data: { seoScore: 80 },
-    ...o,
-  }
-}
-
 const COLLECTIONS_RESPONSE = [
   {
     slug: 'blog',
@@ -54,30 +23,6 @@ const COLLECTIONS_RESPONSE = [
     hidden: false,
     fieldCount: 12,
   },
-  {
-    slug: 'case-studies',
-    labels: { singular: 'Case Study', plural: 'Case Studies' },
-    type: 'post',
-    urlPrefix: 'case-studies',
-    description: 'Case studies',
-    icon: 'briefcase',
-    color: 'green',
-    group: 'Posts',
-    hidden: false,
-    fieldCount: 13,
-  },
-  {
-    slug: 'news',
-    labels: { singular: 'News Item', plural: 'News' },
-    type: 'post',
-    urlPrefix: 'news',
-    description: 'News',
-    icon: 'newspaper',
-    color: 'orange',
-    group: 'Posts',
-    hidden: false,
-    fieldCount: 11,
-  },
   {
     slug: 'pages',
     labels: { singular: 'Page', plural: 'Pages' },
@@ -92,84 +37,95 @@ const COLLECTIONS_RESPONSE = [
   },
 ]
 
-const USERS_RESPONSE = {
-  users: [
-    { id: 'u-sarah', name: 'Sarah Morgan', email: 'sarah@example.com' },
-    { id: 'u-maria', name: 'Maria K', email: 'maria@example.com' },
-    { id: 'u-david', name: 'David Carlson', email: 'david@example.com' },
-  ],
-}
-
-const DOCS: Record<string, DocFixture[]> = {
-  blog: [
-    doc({
+// Canned response from the server-side `GET /posts` aggregate. The server now
+// owns filtering/sorting/pagination, so the client tests assert the mapping
+// from this envelope onto the Post / PostType / PostAuthor shapes and that the
+// query params are forwarded.
+const POSTS_RESPONSE = {
+  posts: [
+    {
+      id: 'n1',
+      collection: 'news',
+      title: 'Q2 2026 Product Roadmap Update',
+      slug: 'q2-roadmap',
+      status: 'SCHEDULED' as const,
+      publishedAt: null,
+      scheduledAt: '2026-06-01T00:00:00.000Z',
+      createdAt: '2026-05-10T00:00:00.000Z',
+      updatedAt: '2026-05-24T00:00:00.000Z',
+      seoScore: 62,
+      author: { id: 'u-sarah', name: 'Sarah Morgan' },
+    },
+    {
       id: 'b1',
       collection: 'blog',
       title: 'The Future of AI Content Marketing',
       slug: 'ai-content-marketing',
-      createdById: 'u-maria',
-      updatedById: 'u-maria',
+      status: 'PUBLISHED' as const,
+      publishedAt: '2026-05-10T00:00:00.000Z',
+      scheduledAt: null,
+      createdAt: '2026-05-10T00:00:00.000Z',
       updatedAt: '2026-05-18T00:00:00.000Z',
-      data: { seoScore: 88 },
-    }),
-    doc({
-      id: 'b2',
-      collection: 'blog',
-      title: 'ActuateCMS vs Contentful',
-      slug: 'actuatecms-vs-contentful',
-      updatedAt: '2026-05-15T00:00:00.000Z',
-      data: { seoScore: 92 },
-    }),
-    doc({
+      seoScore: 88,
+      author: { id: 'u-maria', name: 'Maria K' },
+    },
+    {
       id: 'b3',
       collection: 'blog',
       title: 'Mid-Year Review',
       slug: 'mid-year-cms-trends',
-      status: 'DRAFT',
-      createdById: 'u-sarah',
-      updatedById: 'u-sarah',
+      status: 'DRAFT' as const,
       publishedAt: null,
+      scheduledAt: null,
+      createdAt: '2026-05-10T00:00:00.000Z',
       updatedAt: '2026-05-22T00:00:00.000Z',
-      data: { seoScore: null },
-    }),
+      seoScore: null,
+      author: null,
+    },
   ],
-  'case-studies': [
-    doc({
-      id: 'c1',
-      collection: 'case-studies',
-      title: 'Healthcare Client SEO Results',
-      slug: 'healthcare-seo',
-      status: 'DRAFT',
-      publishedAt: null,
-      updatedAt: '2026-05-19T00:00:00.000Z',
-      data: { seoScore: 38 },
-    }),
+  total: 5,
+  page: 1,
+  pageSize: 10,
+  types: [
+    {
+      slug: 'blog',
+      singular: 'Blog Post',
+      plural: 'Blog',
+      description: 'Blog posts',
+      urlPrefix: 'blog',
+      color: 'purple',
+      icon: 'file-text',
+      fieldCount: 12,
+      count: 3,
+    },
+    {
+      slug: 'news',
+      singular: 'News Item',
+      plural: 'News',
+      description: 'News',
+      urlPrefix: 'news',
+      color: 'orange',
+      icon: 'newspaper',
+      fieldCount: 11,
+      count: 1,
+    },
   ],
-  news: [
-    doc({
-      id: 'n1',
-      collection: 'news',
-      title: 'Q2 2026 Product Roadmap Update',
-      slug: 'q2-roadmap',
-      status: 'SCHEDULED',
-      createdById: 'u-sarah',
-      updatedById: 'u-sarah',
-      publishedAt: null,
-      scheduledAt: '2026-06-01T00:00:00.000Z',
-      updatedAt: '2026-05-24T00:00:00.000Z',
-      data: { seoScore: 62 },
-    }),
+  authors: [
+    { id: 'u-sarah', name: 'Sarah Morgan' },
+    { id: 'u-maria', name: 'Maria K' },
   ],
 }
 
+/** Records the last `/posts` URL the service requested. */
+let lastPostsUrl = ''
+
 function installDefaultMocks() {
+  lastPostsUrl = ''
   cmsApiMock.mockImplementation((url: string) => {
     if (url === '/collections') return { data: COLLECTIONS_RESPONSE }
-    if (url.startsWith('/users')) return { data: USERS_RESPONSE }
-    const m = url.match(/^\/collections\/([^/?]+)/)
-    if (m && m[1]) {
-      const slug = decodeURIComponent(m[1])
-      return { data: { docs: DOCS[slug] ?? [], total: DOCS[slug]?.length ?? 0 } }
+    if (url.startsWith('/posts')) {
+      lastPostsUrl = url
+      return { data: POSTS_RESPONSE }
     }
     return { error: `unexpected url: ${url}` }
   })
@@ -183,7 +139,7 @@ describe('posts-service.fetchPostTypes', () => {
 
   it('returns only post-typed collections (filters out type: page)', async () => {
     const types = await fetchPostTypes()
-    expect(types.map((t) => t.slug).sort()).toEqual(['blog', 'case-studies', 'news'])
+    expect(types.map((t) => t.slug).sort()).toEqual(['blog'])
   })
 
   it('maps collection metadata onto the PostType shape', async () => {
@@ -212,68 +168,83 @@ describe('posts-service.fetchPosts', () => {
     installDefaultMocks()
   })
 
-  it('aggregates posts across all post-typed collections', async () => {
-    const res = await fetchPosts({ pageSize: 20 })
+  it('maps the server posts onto the Post shape', async () => {
+    const res = await fetchPosts({ pageSize: 10 })
     expect(res.total).toBe(5)
-    expect(res.posts.map((p) => p.id).sort()).toEqual(['b1', 'b2', 'b3', 'c1', 'n1'])
-  })
-
-  it('joins authors via /users', async () => {
-    const res = await fetchPosts({ pageSize: 20 })
-    const ai = res.posts.find((p) => p.id === 'b1')
-    expect(ai?.authorName).toBe('Maria K')
-    expect(ai?.authorInitials).toBe('MK')
-  })
-
-  it('sorts by updated date desc by default and surfaces scheduled date for SCHEDULED posts', async () => {
-    const res = await fetchPosts({ pageSize: 20 })
-    // The SCHEDULED news post should win the "date" sort because its
-    // scheduledAt is the most recent date in the fixture set.
-    expect(res.posts[0]?.id).toBe('n1')
-    expect(res.posts[0]?.publishDate).toBe('2026-06-01T00:00:00.000Z')
+    expect(res.posts.map((p) => p.id)).toEqual(['n1', 'b1', 'b3'])
+    const blogPost = res.posts.find((p) => p.id === 'b1')
+    expect(blogPost).toMatchObject({
+      title: 'The Future of AI Content Marketing',
+      postTypeId: 'blog',
+      postTypeName: 'Blog Post',
+      postTypeAccentColor: 'purple',
+      authorId: 'u-maria',
+      authorName: 'Maria K',
+      authorInitials: 'MK',
+      status: 'PUBLISHED',
+      seoScore: 88,
+    })
   })
 
-  it('filters by postType', async () => {
-    const res = await fetchPosts({ postType: 'blog', pageSize: 20 })
-    expect(res.total).toBe(3)
-    expect(res.posts.every((p) => p.postTypeId === 'blog')).toBe(true)
+  it('surfaces the scheduled date for SCHEDULED posts as the display date', async () => {
+    const res = await fetchPosts({})
+    const news = res.posts.find((p) => p.id === 'n1')
+    expect(news?.publishDate).toBe('2026-06-01T00:00:00.000Z')
+    expect(news?.updatedDate).toBe('2026-06-01T00:00:00.000Z')
   })
 
-  it('filters by status', async () => {
-    const res = await fetchPosts({ status: 'DRAFT', pageSize: 20 })
-    expect(res.posts.map((p) => p.id).sort()).toEqual(['b3', 'c1'])
+  it('falls back gracefully when a post has no author', async () => {
+    const res = await fetchPosts({})
+    const orphan = res.posts.find((p) => p.id === 'b3')
+    expect(orphan?.authorName).toBe('Unknown')
+    expect(orphan?.authorInitials).toBe('??')
+    expect(orphan?.authorId).toBe('')
   })
 
-  it('filters by author', async () => {
-    const res = await fetchPosts({ author: 'u-sarah', pageSize: 20 })
-    expect(res.posts.map((p) => p.id).sort()).toEqual(['b3', 'n1'])
+  it('maps the dataset-wide tab counts from the endpoint', async () => {
+    const res = await fetchPosts({})
+    expect(res.types.find((t) => t.slug === 'blog')?.postCount).toBe(3)
+    expect(res.types.find((t) => t.slug === 'news')?.postCount).toBe(1)
   })
 
-  it('searches across title, slug, author name, and post type', async () => {
-    const res = await fetchPosts({ search: 'roadmap' })
-    expect(res.posts).toHaveLength(1)
-    expect(res.posts[0]?.id).toBe('n1')
+  it('returns the contributor list sorted by name', async () => {
+    const res = await fetchPosts({})
+    expect(res.authors.map((a) => a.name)).toEqual(['Maria K', 'Sarah Morgan'])
   })
 
-  it('paginates and exposes the unfiltered tab counts', async () => {
-    const res = await fetchPosts({ pageSize: 2 })
-    expect(res.posts).toHaveLength(2)
-    expect(res.total).toBe(5)
-    const blogTab = res.types.find((t) => t.slug === 'blog')
-    expect(blogTab?.postCount).toBe(3)
-    const newsTab = res.types.find((t) => t.slug === 'news')
-    expect(newsTab?.postCount).toBe(1)
+  it('forwards filter / sort / pagination params to the endpoint', async () => {
+    await fetchPosts({
+      search: 'roadmap',
+      postType: 'news',
+      status: 'SCHEDULED',
+      author: 'u-sarah',
+      sortBy: 'title',
+      sortDirection: 'asc',
+      page: 2,
+      pageSize: 25,
+    })
+    const params = new URLSearchParams(lastPostsUrl.split('?')[1] ?? '')
+    expect(params.get('search')).toBe('roadmap')
+    expect(params.get('postType')).toBe('news')
+    expect(params.get('status')).toBe('SCHEDULED')
+    expect(params.get('author')).toBe('u-sarah')
+    expect(params.get('sortBy')).toBe('title')
+    expect(params.get('sortDirection')).toBe('asc')
+    expect(params.get('page')).toBe('2')
+    expect(params.get('pageSize')).toBe('25')
   })
 
-  it('returns only authors actually present on posts', async () => {
-    const res = await fetchPosts({ pageSize: 20 })
-    expect(res.authors.map((a) => a.id).sort()).toEqual(['u-david', 'u-maria', 'u-sarah'])
+  it('omits "all" filters from the query string', async () => {
+    await fetchPosts({ postType: 'all', status: 'all', author: 'all' })
+    const params = new URLSearchParams(lastPostsUrl.split('?')[1] ?? '')
+    expect(params.has('postType')).toBe(false)
+    expect(params.has('status')).toBe(false)
+    expect(params.has('author')).toBe(false)
   })
 
-  it('uses the postType filter to scope the result set without touching the tab counts', async () => {
-    const res = await fetchPosts({ postType: 'news', pageSize: 20 })
-    expect(res.total).toBe(1)
-    // Tab counts still reflect the full corpus.
-    expect(res.types.find((t) => t.slug === 'blog')?.postCount).toBe(3)
+  it('throws when the endpoint returns an error', async () => {
+    cmsApiMock.mockReset()
+    cmsApiMock.mockImplementation(() => ({ error: 'boom' }))
+    await expect(fetchPosts({})).rejects.toThrow('boom')
   })
 })