@actuate-media/cms-admin 0.18.0 → 0.20.0

package/src/lib/posts-service.ts

@@ -1,25 +1,16 @@
 /**
- * Posts service — thin client over the existing REST endpoints,
- * shaped around the data the Posts admin area needs.
+ * Posts service — thin client over the CMS REST endpoints, shaped around the
+ * data the Posts admin area needs.
  *
- * V1 strategy: aggregate across post-typed collections client-side
- * (one `/collections/:slug` call per type) and join authors via
- * `/users`. Each view component pulls from `fetchPosts()` so when
- * a server-side `/api/cms/posts` endpoint lands later, only this
- * file changes — callers consume the same `Post[]` / `PostType[]`
- * shapes.
+ * `fetchPosts` calls the server-side aggregate endpoint `GET /posts`, which
+ * does the cross-collection filter / sort / paginate at the DB level (one
+ * query + one count) and returns the post rows alongside dataset-wide type
+ * counts and the contributor list. This keeps the Posts list O(page) instead
+ * of pulling every document per type into the browser, and lets it scale past
+ * the old ~500-row-per-type client cap.
  *
- * Why not a single `/collections/all` call?
- *   - Each collection has its own access-control check, so listing
- *     across collections must respect per-collection `read` rules.
- *     The existing endpoint enforces this per-call; mixing them
- *     server-side would need a new auth boundary.
- *   - V1 traffic is small (the seed is 15 rows); a few extra
- *     parallel requests are well under the rate-limit budget.
- *
- * Promote to a single endpoint when:
- *   - Any post-type collection grows past ~5k rows, OR
- *   - Page-load latency exceeds 300ms in the admin metrics.
+ * Access control still lives server-side: the endpoint only returns rows from
+ * collections the caller's scope can read.
  */
 import { cmsApi } from './api.js'
 
@@ -133,204 +124,142 @@ function collectionToPostType(c: CollectionApiRow, count = 0): PostType {
   }
 }
 
-// ─── Users → Authors ─────────────────────────────────────────────────
+// ─── Authors ─────────────────────────────────────────────────────────
 
-interface UserApiRow {
-  id: string
-  name?: string | null
-  email: string
+function initialsFromName(name: string | null | undefined): string {
+  const trimmed = name?.trim()
+  if (!trimmed) return '?'
+  const parts = trimmed.split(/\s+/)
+  const first = parts[0]?.[0] ?? ''
+  const last = parts.length > 1 ? (parts[parts.length - 1]?.[0] ?? '') : ''
+  return (first + last).toUpperCase() || '?'
 }
 
-function initialsFromName(name: string | null | undefined, email: string): string {
-  if (name && name.trim().length > 0) {
-    const parts = name.trim().split(/\s+/)
-    const first = parts[0]?.[0] ?? ''
-    const last = parts.length > 1 ? (parts[parts.length - 1]?.[0] ?? '') : ''
-    return (first + last).toUpperCase() || (email[0] ?? '?').toUpperCase()
-  }
-  return (email[0] ?? '?').toUpperCase()
-}
+// ─── Posts (server-side aggregate) ───────────────────────────────────
 
-async function fetchAuthorsMap(): Promise<Map<string, PostAuthor>> {
-  const res = await cmsApi<{ users: UserApiRow[] } | UserApiRow[]>('/users?pageSize=200')
-  const list: UserApiRow[] = Array.isArray(res.data)
-    ? res.data
-    : ((res.data as { users?: UserApiRow[] } | null)?.users ?? [])
-  const map = new Map<string, PostAuthor>()
-  for (const u of list) {
-    map.set(u.id, {
-      id: u.id,
-      name: u.name?.trim() || u.email,
-      initials: initialsFromName(u.name, u.email),
-    })
-  }
-  return map
-}
-
-// ─── Posts ───────────────────────────────────────────────────────────
-
-interface DocumentApiRow {
+interface PostsApiPost {
   id: string
   collection: string
   title: string | null
   slug: string | null
   status: PostStatus
-  createdById: string | null
-  updatedById: string | null
   publishedAt: string | null
   scheduledAt: string | null
   createdAt: string
   updatedAt: string
-  data: Record<string, unknown> | null
+  seoScore: number | null
+  author: { id: string; name: string } | null
 }
 
-function extractSeoScore(data: Record<string, unknown> | null): number | null {
-  if (!data) return null
-  const candidates = ['seoScore', 'seo_score', 'metaScore']
-  for (const k of candidates) {
-    const v = data[k]
-    if (typeof v === 'number' && Number.isFinite(v)) return v
-  }
-  return null
+interface PostsApiType {
+  slug: string
+  singular: string
+  plural: string
+  description: string | null
+  urlPrefix: string
+  color: string | null
+  icon: string | null
+  fieldCount: number
+  count: number
+}
+
+interface PostsApiResponse {
+  posts: PostsApiPost[]
+  total: number
+  page: number
+  pageSize: number
+  types: PostsApiType[]
+  authors: Array<{ id: string; name: string }>
 }
 
-function pickDisplayDate(d: DocumentApiRow): string {
+/** Display date matches the old client behaviour: scheduled/published date when set, else updated. */
+function pickDisplayDate(d: PostsApiPost): string {
   if (d.status === 'SCHEDULED' && d.scheduledAt) return d.scheduledAt
   if (d.status === 'PUBLISHED' && d.publishedAt) return d.publishedAt
   return d.updatedAt
 }
 
-interface ListEnvelope {
-  docs: DocumentApiRow[]
-  total: number
+function buildPostsQueryString(query: PostsQuery): string {
+  const params = new URLSearchParams()
+  if (query.search?.trim()) params.set('search', query.search.trim())
+  if (query.postType && query.postType !== 'all') params.set('postType', query.postType)
+  if (query.status && query.status !== 'all') params.set('status', query.status)
+  if (query.author && query.author !== 'all') params.set('author', query.author)
+  if (query.sortBy) params.set('sortBy', query.sortBy)
+  if (query.sortDirection) params.set('sortDirection', query.sortDirection)
+  params.set('page', String(Math.max(1, query.page ?? 1)))
+  params.set('pageSize', String(Math.max(1, query.pageSize ?? 10)))
+  const qs = params.toString()
+  return qs ? `?${qs}` : ''
 }
 
 export async function fetchPosts(query: PostsQuery = {}): Promise<PostsResult> {
-  const cols = await fetchPostCollections()
-  const authorsMap = await fetchAuthorsMap()
-
-  // Pull every doc for each post type (cap at 500 to avoid runaway
-  // requests; pagination + filtering still happens client-side over
-  // this set). When a type grows past 500 docs we'll need the
-  // server-side aggregate endpoint described in this file's header.
-  const perTypeRaw = await Promise.all(
-    cols.map(async (c) => {
-      const res = await cmsApi<ListEnvelope>(
-        `/collections/${encodeURIComponent(c.slug)}?pageSize=500&sort=updatedAt&order=desc`,
-      )
-      const docs = (res.data?.docs ?? []) as DocumentApiRow[]
-      return { col: c, docs }
-    }),
-  )
-
-  // Map docs → Post objects.
-  const allPosts: Post[] = []
-  for (const { col, docs } of perTypeRaw) {
-    for (const d of docs) {
-      const author = (d.createdById && authorsMap.get(d.createdById)) ||
-        (d.updatedById && authorsMap.get(d.updatedById)) || {
-          id: '',
-          name: 'Unknown',
-          initials: '??',
-        }
-      allPosts.push({
-        id: d.id,
-        title: d.title ?? (d.data?.title as string) ?? '(untitled)',
-        slug: d.slug ?? (d.data?.slug as string) ?? '',
-        postTypeId: col.slug,
-        postTypeName: col.labels.singular,
-        postTypeAccentColor: col.color ?? null,
-        authorId: author.id,
-        authorName: author.name,
-        authorInitials: author.initials,
-        status: d.status,
-        publishDate: d.publishedAt ?? d.scheduledAt ?? null,
-        updatedDate: pickDisplayDate(d),
-        seoScore: extractSeoScore(d.data),
-        createdAt: d.createdAt,
-        updatedAt: d.updatedAt,
-      })
-    }
-  }
+  const page = Math.max(1, query.page ?? 1)
+  const pageSize = Math.max(1, query.pageSize ?? 10)
 
-  // Compute per-type counts BEFORE filtering — the tabs at the top
-  // of the page reflect the dataset, not the active query.
-  const countsBySlug = new Map<string, number>()
-  for (const p of allPosts) {
-    countsBySlug.set(p.postTypeId, (countsBySlug.get(p.postTypeId) ?? 0) + 1)
+  const res = await cmsApi<PostsApiResponse>(`/posts${buildPostsQueryString(query)}`)
+  if (res.error || !res.data) {
+    throw new Error(res.error ?? 'Failed to load posts')
   }
-  const types: PostType[] = cols.map((c) => collectionToPostType(c, countsBySlug.get(c.slug) ?? 0))
-
-  // Apply filters / search.
-  const search = (query.search ?? '').trim().toLowerCase()
-  const filtered = allPosts.filter((p) => {
-    if (query.postType && query.postType !== 'all' && p.postTypeId !== query.postType) return false
-    if (query.status && query.status !== 'all' && p.status !== query.status) return false
-    if (query.author && query.author !== 'all' && p.authorId !== query.author) return false
-    if (search) {
-      const haystack = `${p.title} ${p.slug} ${p.authorName} ${p.postTypeName}`.toLowerCase()
-      if (!haystack.includes(search)) return false
+  const r = res.data
+
+  const typeBySlug = new Map<string, PostsApiType>()
+  for (const t of r.types) typeBySlug.set(t.slug, t)
+
+  const types: PostType[] = r.types.map((t) => ({
+    id: t.slug,
+    slug: t.slug,
+    name: t.plural,
+    singularName: t.singular,
+    description: t.description ?? null,
+    urlBase: `/${t.urlPrefix || t.slug}`,
+    accentColor: t.color ?? null,
+    icon: t.icon ?? null,
+    postCount: t.count,
+    fieldCount: t.fieldCount,
+    active: true,
+  }))
+
+  const posts: Post[] = r.posts.map((d) => {
+    const type = typeBySlug.get(d.collection)
+    const authorName = d.author?.name?.trim() || 'Unknown'
+    return {
+      id: d.id,
+      title: d.title ?? '(untitled)',
+      slug: d.slug ?? '',
+      postTypeId: d.collection,
+      postTypeName: type?.singular ?? d.collection,
+      postTypeAccentColor: type?.color ?? null,
+      authorId: d.author?.id ?? '',
+      authorName,
+      authorInitials: d.author ? initialsFromName(d.author.name) : '??',
+      status: d.status,
+      publishDate: d.publishedAt ?? d.scheduledAt ?? null,
+      updatedDate: pickDisplayDate(d),
+      seoScore: d.seoScore,
+      createdAt: d.createdAt,
+      updatedAt: d.updatedAt,
     }
-    return true
   })
 
-  // Sort.
-  const sortBy = query.sortBy ?? 'date'
-  const dir = query.sortDirection ?? 'desc'
-  filtered.sort((a, b) => {
-    const cmp = comparePostsFor(sortBy, a, b)
-    return dir === 'asc' ? cmp : -cmp
-  })
-
-  // Paginate.
-  const page = Math.max(1, query.page ?? 1)
-  const pageSize = Math.max(1, query.pageSize ?? 10)
-  const start = (page - 1) * pageSize
-  const paged = filtered.slice(start, start + pageSize)
-
-  // Unique authors from the full set (so the dropdown lists every
-  // contributor, not just the currently visible page).
-  const authorIds = new Set<string>()
-  const authors: PostAuthor[] = []
-  for (const p of allPosts) {
-    if (p.authorId && !authorIds.has(p.authorId)) {
-      authorIds.add(p.authorId)
-      authors.push({ id: p.authorId, name: p.authorName, initials: p.authorInitials })
-    }
-  }
-  authors.sort((a, b) => a.name.localeCompare(b.name))
+  const authors: PostAuthor[] = r.authors
+    .map((a) => ({
+      id: a.id,
+      name: a.name?.trim() || 'Unknown',
+      initials: initialsFromName(a.name),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name))
 
   return {
-    posts: paged,
-    total: filtered.length,
-    page,
-    pageSize,
+    posts,
+    total: r.total,
+    page: r.page ?? page,
+    pageSize: r.pageSize ?? pageSize,
     types,
     authors,
   }
 }
 
-function comparePostsFor(by: NonNullable<PostsQuery['sortBy']>, a: Post, b: Post): number {
-  switch (by) {
-    case 'title':
-      return a.title.localeCompare(b.title)
-    case 'type':
-      return a.postTypeName.localeCompare(b.postTypeName)
-    case 'author':
-      return a.authorName.localeCompare(b.authorName)
-    case 'status':
-      return a.status.localeCompare(b.status)
-    case 'seo': {
-      const av = a.seoScore ?? -1
-      const bv = b.seoScore ?? -1
-      return av - bv
-    }
-    case 'date':
-    default:
-      return new Date(a.updatedDate).getTime() - new Date(b.updatedDate).getTime()
-  }
-}
-
 // ─── Bulk mutations ──────────────────────────────────────────────────
 
 export async function bulkUpdatePosts(