@stacksjs/defaults 0.75.482 → 0.75.484

package/app/Actions/Dashboard/Content/comment-list.ts

@@ -0,0 +1,311 @@
+import { db, getDatabaseDialect, sqlHelpers } from '@stacksjs/database/runtime'
+import type { CommentableRow, CommentStatus, DashboardComment } from './comment-input'
+import { COMMENT_STATUSES, commentableRecord, dashboardStatusForCommentable, isMissingTableError, isSafeTableName, newestFirst, normalizeCommentStatus, parseCommentableRow } from './comment-input'
+import type { ListQuery, QueryReader } from './content-list'
+import { countOf, pageWithin, parseListQuery, queryText } from './content-list'
+
+/**
+ * One page of the dashboard's comments, read by the database.
+ *
+ * Comments live in two tables: `comments`, the CMS table, and `commentables`,
+ * the polymorphic one the `commentable` trait writes. The list used to read
+ * both whole and the page rendered every comment at once
+ * (stacksjs/stacks#3193). Now each table is searched, filtered and counted in
+ * SQL. A page is newest first across both: for page p of n, each table gives
+ * its newest p * n matches, which must hold the page, and the two are merged
+ * by date and sliced. That costs more for deep pages, never more than the
+ * matching rows.
+ */
+
+export type CommentListQuery = ListQuery<'created_at'> & { status: CommentStatus | 'all' }
+
+export interface CommentCounts {
+  all: number
+  pending: number
+  approved: number
+  spam: number
+  trash: number
+}
+
+export interface CommentPage {
+  rows: DashboardComment[]
+  /** Comments matching the search and status, which the pager counts. */
+  total: number
+  /** The page the rows are, moved back to the last one when it ran past it. */
+  page: number
+  /** Every comment by status, whatever the search, for the summary cards. */
+  counts: CommentCounts
+}
+
+export function parseCommentListQuery(read: QueryReader): CommentListQuery | { error: string } {
+  const list = parseListQuery(read, ['created_at'] as const)
+  if ('error' in list)
+    return list
+  if (list.direction !== 'desc')
+    return { error: 'Comments are listed newest first; direction must be desc.' }
+
+  const status = queryText(read, 'status') || 'all'
+  if (status !== 'all' && !(COMMENT_STATUSES as readonly string[]).includes(status))
+    return { error: `status must be all or one of ${COMMENT_STATUSES.join(', ')}.` }
+
+  return { ...list, status: status as CommentListQuery['status'] }
+}
+
+/** A timestamp as text that sorts: PostgreSQL hands back a Date, SQLite a string. */
+function timestampText(value: unknown): string | null {
+  if (value instanceof Date)
+    return Number.isNaN(value.getTime()) ? null : value.toISOString()
+  return value === undefined || value === null || value === '' ? null : String(value)
+}
+
+/* ------------------------------------------------------------ comments */
+
+interface CommentRow {
+  id: number
+  author_name: string | null
+  author_email: string | null
+  content: string | null
+  body: string | null
+  post_title: string | null
+  status: string | null
+  is_approved: number | boolean | null
+  created_at: unknown
+  updated_at: unknown
+}
+
+function legacyRecord(row: CommentRow): DashboardComment {
+  return {
+    key: `comments:${row.id}`,
+    source: 'comments',
+    id: Number(row.id),
+    author_name: String(row.author_name || ''),
+    author_email: String(row.author_email || ''),
+    content: String(row.content || row.body || ''),
+    post_title: String(row.post_title || ''),
+    status: normalizeCommentStatus(row.status),
+    is_approved: Boolean(row.is_approved),
+    created_at: timestampText(row.created_at),
+    updated_at: timestampText(row.updated_at),
+  }
+}
+
+/** `comments.status` is an enum or CHECK of exactly these values, so it compares as is. */
+function legacyFiltered(query: CommentListQuery): any {
+  let chain: any = db.selectFrom('comments')
+  if (query.status !== 'all')
+    chain = chain.where('status', '=', query.status)
+  if (query.search) {
+    const term = `%${query.search}%`
+    chain = chain.whereGroup((group: any) => group
+      .whereLike('content', term)
+      .orWhereLike('body', term)
+      .orWhereLike('author_name', term)
+      .orWhereLike('author_email', term)
+      .orWhereLike('post_title', term))
+  }
+  return chain
+}
+
+async function legacyTotal(query: CommentListQuery): Promise<number> {
+  return countOf((await legacyFiltered(query).select(db.fn.count('id').as('count')).executeTakeFirst() as { count?: unknown } | undefined)?.count)
+}
+
+async function legacyRows(query: CommentListQuery, limit: number): Promise<DashboardComment[]> {
+  const rows = await legacyFiltered(query)
+    .select(['id', 'author_name', 'author_email', 'content', 'body', 'post_title', 'status', 'is_approved', 'created_at', 'updated_at'])
+    .orderBy('created_at', 'desc')
+    .orderBy('id', 'desc')
+    .limit(limit)
+    .execute() as CommentRow[]
+
+  return rows.map(legacyRecord)
+}
+
+/* -------------------------------------------------------- commentables */
+
+/**
+ * The column that names each kind of thing a trait comment was left on, by
+ * table: its title, else its name. A type that is not a safe identifier, has
+ * no such table, or has neither column has none, and its comments show a
+ * plain `posts #3` label, as they always did.
+ */
+async function ownerLabelColumns(types: string[]): Promise<Map<string, 'title' | 'name'>> {
+  const columns = new Map<string, 'title' | 'name'>()
+  for (const type of types) {
+    if (!isSafeTableName(type))
+      continue
+    for (const column of ['title', 'name'] as const) {
+      try {
+        await db.unsafe(`SELECT id, ${column} FROM ${type} WHERE 1 = 0`).execute()
+        columns.set(type, column)
+        break
+      }
+      catch {
+        // No such table or no such column: try the next column, then none.
+      }
+    }
+  }
+  return columns
+}
+
+/** What each trait comment on the page was left on, keyed `type:id`. */
+async function ownerLabels(rows: CommentableRow[], columns: Map<string, 'title' | 'name'>): Promise<Map<string, string>> {
+  const labels = new Map<string, string>()
+  const idsByType = new Map<string, number[]>()
+
+  for (const row of rows) {
+    const type = String(row.commentables_type || '')
+    labels.set(`${type}:${row.commentables_id}`, `${type} #${row.commentables_id}`)
+    if (columns.has(type))
+      idsByType.set(type, [...(idsByType.get(type) ?? []), Number(row.commentables_id)])
+  }
+
+  for (const [type, ids] of idsByType) {
+    const column = columns.get(type)!
+    const owners = await (db as any).selectFrom(type).select(['id', column]).whereIn('id', [...new Set(ids)]).execute() as Array<Record<string, unknown>>
+    for (const owner of owners) {
+      const label = String(owner[column] ?? '').trim()
+      if (label)
+        labels.set(`${type}:${owner.id}`, label)
+    }
+  }
+
+  return labels
+}
+
+/**
+ * The trait's status column is free text, so it is compared lowercased. It has
+ * one hidden state, `rejected`, which the dashboard shows as spam, and none
+ * that shows as trash. The values are constants, never input.
+ */
+const COMMENTABLE_STATUS_SQL: Record<CommentStatus, string> = {
+  approved: `LOWER(status) = 'approved'`,
+  spam: `LOWER(status) = 'rejected'`,
+  trash: '1 = 0',
+  pending: `(status IS NULL OR LOWER(status) NOT IN ('approved', 'rejected'))`,
+}
+
+/**
+ * The WHERE clause for trait comments, and its bound values.
+ *
+ * Raw rather than the builder because a match on what a comment was left on
+ * is a subquery per owner table, and the builder takes no bound values in a
+ * raw fragment. Every value here is bound; only table and column names that
+ * passed `isSafeTableName` and the probe above are written into the text.
+ */
+function commentableWhere(query: CommentListQuery, columns: Map<string, 'title' | 'name'>, guestAuthors: boolean): { sql: string, values: unknown[] } {
+  const helpers = sqlHelpers(getDatabaseDialect())
+  const clauses: string[] = []
+  const values: unknown[] = []
+  const bind = (value: unknown): string => {
+    values.push(value)
+    return helpers.param(values.length)
+  }
+
+  if (query.status !== 'all')
+    clauses.push(COMMENTABLE_STATUS_SQL[query.status])
+
+  if (query.search) {
+    const term = `%${query.search}%`
+    const searched = guestAuthors ? ['title', 'body', 'author_name', 'author_email'] : ['title', 'body']
+    const matches = searched.map(column => `LOWER(${column}) LIKE LOWER(${bind(term)})`)
+    for (const [type, column] of columns)
+      matches.push(`(commentables_type = '${type}' AND commentables_id IN (SELECT id FROM ${type} WHERE LOWER(${column}) LIKE LOWER(${bind(term)})))`)
+    clauses.push(`(${matches.join(' OR ')})`)
+  }
+
+  return { sql: clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '', values }
+}
+
+interface CommentableSource {
+  columns: Map<string, 'title' | 'name'>
+  guestAuthors: boolean
+  where: { sql: string, values: unknown[] }
+  total: number
+  statusRows: Array<{ status: unknown, count: unknown }>
+}
+
+/** The trait comments' filter, match count and status counts, or null without the table. */
+async function prepareCommentables(query: CommentListQuery): Promise<CommentableSource | null> {
+  let types: string[]
+  try {
+    const found = await db.unsafe('SELECT DISTINCT commentables_type FROM commentables').execute() as Array<{ commentables_type: string }>
+    types = found.map(row => String(row.commentables_type))
+  }
+  catch (error) {
+    // An app that never migrated the trait tables has no trait comments,
+    // which is not an error; any other failure is.
+    if (isMissingTableError(error))
+      return null
+    throw error
+  }
+
+  // The guest-author columns came after the table, and `migrate` adds them.
+  // Until it has, a trait comment has no author name or email, as before,
+  // rather than the list failing.
+  let guestAuthors = true
+  try {
+    await db.unsafe('SELECT author_name, author_email FROM commentables WHERE 1 = 0').execute()
+  }
+  catch {
+    guestAuthors = false
+  }
+
+  const columns = await ownerLabelColumns(types)
+  const where = commentableWhere(query, columns, guestAuthors)
+  const [[counted], statusRows] = await Promise.all([
+    db.unsafe(`SELECT COUNT(id) AS count FROM commentables ${where.sql}`, where.values).execute() as Promise<Array<{ count: unknown }>>,
+    db.unsafe('SELECT status, COUNT(id) AS count FROM commentables GROUP BY status').execute() as Promise<Array<{ status: unknown, count: unknown }>>,
+  ])
+
+  return { columns, guestAuthors, where, total: countOf(counted?.count), statusRows }
+}
+
+async function commentableRows(source: CommentableSource, limit: number): Promise<DashboardComment[]> {
+  const rows = (await db.unsafe(
+    `SELECT id, title, body, status, commentables_id, commentables_type, user_id, ${source.guestAuthors ? 'author_name, author_email' : 'NULL AS author_name, NULL AS author_email'}, created_at, updated_at
+     FROM commentables ${source.where.sql} ORDER BY created_at DESC, id DESC LIMIT ${Math.trunc(limit)}`,
+    source.where.values,
+  ).execute()).map(parseCommentableRow)
+
+  const labels = await ownerLabels(rows, source.columns)
+  return rows.map(row => ({
+    ...commentableRecord(row, labels.get(`${row.commentables_type}:${row.commentables_id}`) ?? ''),
+    created_at: timestampText(row.created_at),
+    updated_at: timestampText(row.updated_at),
+  }))
+}
+
+/* ---------------------------------------------------------------- page */
+
+async function legacyCounts(): Promise<Array<{ status: unknown, count: unknown }>> {
+  return await db.selectFrom('comments').select(['status', db.fn.count('id').as('count')]).groupBy('status').execute() as Array<{ status: unknown, count: unknown }>
+}
+
+export async function readCommentPage(query: CommentListQuery): Promise<CommentPage> {
+  // The totals first, so the page can be moved back inside them before any
+  // row is read.
+  const [commentTotal, trait, legacyStatusRows] = await Promise.all([legacyTotal(query), prepareCommentables(query), legacyCounts()])
+  const total = commentTotal + (trait?.total ?? 0)
+  const page = pageWithin(query.page, total, query.perPage)
+  const limit = page * query.perPage
+
+  const [legacy, traitRows] = await Promise.all([
+    commentTotal > 0 ? legacyRows(query, limit) : Promise.resolve([]),
+    trait && trait.total > 0 ? commentableRows(trait, limit) : Promise.resolve([]),
+  ])
+
+  const counts: CommentCounts = { all: 0, pending: 0, approved: 0, spam: 0, trash: 0 }
+  for (const row of legacyStatusRows)
+    counts[normalizeCommentStatus(row.status)] += countOf(row.count)
+  for (const row of trait?.statusRows ?? [])
+    counts[dashboardStatusForCommentable(row.status)] += countOf(row.count)
+  counts.all = counts.pending + counts.approved + counts.spam + counts.trash
+
+  return {
+    rows: [...legacy, ...traitRows].sort(newestFirst).slice((page - 1) * query.perPage, limit),
+    total,
+    page,
+    counts,
+  }
+}

package/app/Actions/Dashboard/Content/content-list.ts

@@ -0,0 +1,69 @@
+/**
+ * The query a paged dashboard content list takes, read and checked once for
+ * every list that pages on the server (stacksjs/stacks#3191, #3192).
+ */
+
+export const LIST_PAGE_SIZES = [10, 25, 50, 100] as const
+
+export interface ListQuery<Sort extends string> {
+  page: number
+  perPage: number
+  search: string
+  sort: Sort
+  direction: 'asc' | 'desc'
+}
+
+/** Reads one query value, in whatever shape the request holds it. */
+export type QueryReader = (key: string) => unknown
+
+/** One value as a string: the first of a repeated key, or empty when absent. */
+export function queryText(read: QueryReader, key: string): string {
+  const value = read(key)
+  if (Array.isArray(value))
+    return value.length > 0 ? String(value[0]).trim() : ''
+  return value === undefined || value === null ? '' : String(value).trim()
+}
+
+/**
+ * The page, size, search and sort, or the reason they are invalid.
+ *
+ * Absent values take the defaults these pages have always shown: the first
+ * page of 25, newest first. A value that is present and wrong is an error
+ * rather than a silent default, so a broken caller is visible.
+ */
+export function parseListQuery<Sort extends string>(read: QueryReader, sorts: readonly Sort[]): ListQuery<Sort> | { error: string } {
+  const pageText = queryText(read, 'page')
+  const page = pageText === '' ? 1 : Number(pageText)
+  if (!Number.isInteger(page) || page < 1)
+    return { error: 'page must be a whole number of 1 or more.' }
+
+  const sizeText = queryText(read, 'per_page')
+  const perPage = sizeText === '' ? 25 : Number(sizeText)
+  if (!(LIST_PAGE_SIZES as readonly number[]).includes(perPage))
+    return { error: `per_page must be one of ${LIST_PAGE_SIZES.join(', ')}.` }
+
+  const sort = queryText(read, 'sort') || 'created_at'
+  if (!(sorts as readonly string[]).includes(sort))
+    return { error: `sort must be one of ${sorts.join(', ')}.` }
+
+  const directionText = queryText(read, 'direction').toLowerCase()
+  const direction = directionText === '' ? (sort === 'created_at' ? 'desc' : 'asc') : directionText
+  if (direction !== 'asc' && direction !== 'desc')
+    return { error: 'direction must be asc or desc.' }
+
+  const search = queryText(read, 'search')
+  if (search.length > 200)
+    return { error: 'search must be 200 characters or fewer.' }
+
+  return { page, perPage, search, sort: sort as Sort, direction }
+}
+
+/** The page to show: the one asked for, or the last one when it ran past the end. */
+export function pageWithin(page: number, total: number, perPage: number): number {
+  return Math.min(page, Math.max(1, Math.ceil(total / perPage)))
+}
+
+/** A COUNT or SUM read back as a number, whichever type the driver returned. */
+export function countOf(value: unknown): number {
+  return Number(value ?? 0) || 0
+}

package/app/Actions/Dashboard/Content/page-list.ts

@@ -0,0 +1,108 @@
+import { db, sql } from '@stacksjs/database/runtime'
+import type { ListQuery, QueryReader } from './content-list'
+import { countOf, pageWithin, parseListQuery } from './content-list'
+
+/**
+ * One page of the dashboard's CMS pages list, read by the database.
+ *
+ * The list used to `SELECT *` every page, block documents included, and hand
+ * the whole table to the browser to search and page (stacksjs/stacks#3192).
+ * Now the database searches, sorts, counts and pages, and a row carries only
+ * the columns the list shows and the editor edits.
+ */
+
+export const PAGE_SORTS = ['created_at', 'title', 'published'] as const
+
+export type PageSort = typeof PAGE_SORTS[number]
+export type PageListQuery = ListQuery<PageSort>
+
+export interface PageListRow {
+  id: number
+  title: string | null
+  template: string | null
+  views: number | null
+  conversions: number | null
+  published_at: string | null
+  author_id: number | null
+  created_at: string | null
+  updated_at: string | null
+}
+
+export interface PageListPage {
+  rows: PageListRow[]
+  /** Pages matching the search, which the pager counts. */
+  total: number
+  /** The page the rows are, moved back to the last one when it ran past it. */
+  page: number
+  /** Every page, whatever the search, for the summary cards. */
+  allCount: number
+  totalViews: number
+  totalConversions: number
+  /** The most recently created page's title, or empty when there are none. */
+  newestTitle: string
+}
+
+export function parsePageListQuery(read: QueryReader): PageListQuery | { error: string } {
+  return parseListQuery(read, PAGE_SORTS)
+}
+
+/** The search that a page and its count share: the title, and the template shown under it. */
+function filtered(query: PageListQuery, database: typeof db): any {
+  let chain: any = database.selectFrom('pages')
+  if (query.search) {
+    const term = `%${query.search}%`
+    chain = chain.whereGroup((group: any) => group
+      .whereLike('title', term)
+      .orWhereLike('template', term))
+  }
+  return chain
+}
+
+/**
+ * The same order on every dialect. "Published" is whether a page has a
+ * publish date, drafts first ascending as the table always sorted the badge,
+ * then by that date; titles compare without case. The id breaks ties so a
+ * page boundary is stable between requests.
+ */
+function ordered(chain: any, query: PageListQuery): any {
+  const direction = query.direction === 'asc' ? 'ASC' : 'DESC'
+  if (query.sort === 'published')
+    chain = chain.orderByRaw(sql.raw(`CASE WHEN published_at IS NULL THEN 0 ELSE 1 END ${direction}, published_at ${direction}`))
+  else if (query.sort === 'title')
+    chain = chain.orderByRaw(sql.raw(`LOWER(title) ${direction}`))
+  else
+    chain = chain.orderBy(query.sort, query.direction)
+  return chain.orderBy('id', 'desc')
+}
+
+export async function readPageListPage(query: PageListQuery, database: typeof db = db): Promise<PageListPage> {
+  const total = countOf((await filtered(query, database).select(database.fn.count('id').as('count')).executeTakeFirst() as { count?: unknown } | undefined)?.count)
+  const page = pageWithin(query.page, total, query.perPage)
+
+  const rows = total === 0
+    ? []
+    : await ordered(filtered(query, database), query)
+        .select(['id', 'title', 'template', 'views', 'conversions', 'published_at', 'author_id', 'created_at', 'updated_at'])
+        .limit(query.perPage)
+        .offset((page - 1) * query.perPage)
+        .execute() as PageListRow[]
+
+  const [totals, newest] = await Promise.all([
+    database.selectFrom('pages').select([
+      database.fn.count('id').as('count'),
+      database.fn.sum('views').as('views'),
+      database.fn.sum('conversions').as('conversions'),
+    ]).executeTakeFirst() as Promise<{ count?: unknown, views?: unknown, conversions?: unknown } | undefined>,
+    database.selectFrom('pages').select(['title']).orderBy('created_at', 'desc').orderBy('id', 'desc').limit(1).executeTakeFirst() as Promise<{ title?: string | null } | undefined>,
+  ])
+
+  return {
+    rows,
+    total,
+    page,
+    allCount: countOf(totals?.count),
+    totalViews: countOf(totals?.views),
+    totalConversions: countOf(totals?.conversions),
+    newestTitle: String(newest?.title || ''),
+  }
+}

package/app/Actions/Dashboard/Content/post-list.ts

@@ -0,0 +1,140 @@
+import { db, sql } from '@stacksjs/database/runtime'
+import type { ListQuery, QueryReader } from './content-list'
+import { countOf, LIST_PAGE_SIZES, pageWithin, parseListQuery, queryText } from './content-list'
+
+/**
+ * One page of the dashboard's posts list, read by the database.
+ *
+ * The list used to read every post, article bodies included, and hand the
+ * whole table to the browser to search and page through 25 at a time
+ * (stacksjs/stacks#3191). Now the database filters, counts, sorts and pages,
+ * and a row carries a short preview of its body instead of all of it. The
+ * editor reads one post's body when it opens (`PostShowAction`).
+ */
+
+export const POST_PAGE_SIZES = LIST_PAGE_SIZES
+export const POST_STATUSES = ['draft', 'published', 'archived'] as const
+export const POST_SORTS = ['created_at', 'title', 'status', 'views'] as const
+
+/** How much of a post's body a list row carries, for posts with no excerpt. */
+export const POST_PREVIEW_LENGTH = 240
+
+export type PostStatus = typeof POST_STATUSES[number]
+export type PostSort = typeof POST_SORTS[number]
+
+export interface PostListQuery extends ListQuery<PostSort> {
+  status: PostStatus | 'all'
+}
+
+export interface PostListRow {
+  id: number
+  title: string
+  excerpt: string | null
+  preview: string | null
+  poster: string | null
+  status: string | null
+  views: number | null
+  published_at: string | null
+  created_at: string | null
+  updated_at: string | null
+  author_id: number | null
+  is_featured: number | boolean | null
+}
+
+export interface PostPage {
+  rows: PostListRow[]
+  /** Posts matching the search and status, which the pager counts. */
+  total: number
+  /** The page the rows are, moved back to the last one when it ran past it. */
+  page: number
+  /** Every post, whatever the search, for the page's summary cards. */
+  allCount: number
+  publishedCount: number
+  draftCount: number
+  archivedCount: number
+  totalViews: number
+}
+
+/** The list query, with the post status filter on top of the shared one. */
+export function parsePostListQuery(read: QueryReader): PostListQuery | { error: string } {
+  const list = parseListQuery(read, POST_SORTS)
+  if ('error' in list)
+    return list
+
+  const status = queryText(read, 'status') || 'all'
+  if (status !== 'all' && !(POST_STATUSES as readonly string[]).includes(status))
+    return { error: `status must be all or one of ${POST_STATUSES.join(', ')}.` }
+
+  return { ...list, status: status as PostListQuery['status'] }
+}
+
+/** The search and status that a page and its count share. */
+function filtered(query: PostListQuery, database: typeof db): any {
+  let chain: any = database.selectFrom('posts')
+  if (query.status !== 'all')
+    chain = chain.where('status', '=', query.status)
+  if (query.search) {
+    // Bound, and compared lowercased on every dialect. A `%` or `_` the
+    // viewer types matches as a wildcard, as it does on the models page. The
+    // builder would parenthesise the ORs anyway; the group says so.
+    const term = `%${query.search}%`
+    chain = chain.whereGroup((group: any) => group
+      .whereLike('title', term)
+      .orWhereLike('excerpt', term)
+      .orWhereLike('content', term))
+  }
+  return chain
+}
+
+/**
+ * The order, the same on every dialect. `status` is an enum, which PostgreSQL
+ * and MySQL sort by declaration and SQLite sorts as text, so its order is
+ * spelled out; titles compare without case, as the table always sorted them.
+ * The id last keeps a page boundary stable between requests.
+ */
+function ordered(chain: any, query: PostListQuery): any {
+  const direction = query.direction === 'asc' ? 'ASC' : 'DESC'
+  if (query.sort === 'status')
+    chain = chain.orderByRaw(sql.raw(`CASE status WHEN 'published' THEN 0 WHEN 'draft' THEN 1 ELSE 2 END ${direction}`))
+  else if (query.sort === 'title')
+    chain = chain.orderByRaw(sql.raw(`LOWER(title) ${direction}`))
+  else
+    chain = chain.orderBy(query.sort, query.direction)
+  return chain.orderBy('id', 'desc')
+}
+
+export async function readPostPage(query: PostListQuery, database: typeof db = db): Promise<PostPage> {
+  const total = countOf((await filtered(query, database).select(database.fn.count('id').as('count')).executeTakeFirst() as { count?: unknown } | undefined)?.count)
+  const page = pageWithin(query.page, total, query.perPage)
+
+  const rows = total === 0
+    ? []
+    : await ordered(filtered(query, database), query)
+        .select([
+          'id', 'title', 'excerpt', 'poster', 'status', 'views', 'published_at', 'created_at', 'updated_at', 'author_id', 'is_featured',
+          sql.raw(`SUBSTR(content, 1, ${POST_PREVIEW_LENGTH}) AS preview`),
+        ])
+        .limit(query.perPage)
+        .offset((page - 1) * query.perPage)
+        .execute() as PostListRow[]
+
+  const [byStatus, views] = await Promise.all([
+    database.selectFrom('posts').select(['status', database.fn.count('id').as('count')]).groupBy('status').execute() as Promise<Array<{ status: string, count: unknown }>>,
+    database.selectFrom('posts').select(database.fn.sum('views').as('views')).executeTakeFirst() as Promise<{ views?: unknown } | undefined>,
+  ])
+
+  const statusCount = (status: PostStatus) => byStatus
+    .filter(row => String(row.status).toLowerCase() === status)
+    .reduce((sum, row) => sum + countOf(row.count), 0)
+
+  return {
+    rows,
+    total,
+    page,
+    allCount: byStatus.reduce((sum, row) => sum + countOf(row.count), 0),
+    publishedCount: statusCount('published'),
+    draftCount: statusCount('draft'),
+    archivedCount: statusCount('archived'),
+    totalViews: countOf(views?.views),
+  }
+}

package/app/Actions/Dashboard/Jobs/JobIndexAction.ts

@@ -1,8 +1,7 @@
 import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions/runtime'
-import { FailedJob, Job } from '@stacksjs/orm'
 import { dashboardOperationalError } from '../dashboard-response'
-import { matchesJobSearch, normalizeActiveJob, normalizeFailedJob } from './job-records'
+import { readJobPage } from './job-list'
 
 export default new Action({
   name: 'JobIndexAction',
@@ -16,31 +15,20 @@ export default new Action({
     const search = String(request.get('search', '')).trim().toLowerCase()
 
     try {
-      const [activeJobs, failedJobs] = await Promise.all([
-        Job.orderByDesc('id').get(),
-        FailedJob.orderByDesc('id').get(),
-      ])
+      // An unknown status matched no job before the database did the
+      // filtering, and still matches none.
+      if (statusFilter && statusFilter !== 'all' && !['queued', 'processing', 'failed'].includes(statusFilter))
+        return { data: [], total: 0, page, perPage, queues: [], queueConnected: true }
 
-      const activeNormalized = activeJobs.map(normalizeActiveJob)
-      const failedNormalized = failedJobs.map(normalizeFailedJob)
-
-      const merged = [...activeNormalized, ...failedNormalized].sort((a, b) =>
-        new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
-      )
-
-      const filtered = merged.filter((job) => {
-        if (queueFilter && queueFilter !== 'all' && job.queue !== queueFilter) return false
-        if (statusFilter && statusFilter !== 'all' && job.status !== statusFilter) return false
-        if (!matchesJobSearch(job, search)) return false
-        return true
+      const result = await readJobPage({
+        page,
+        perPage,
+        queue: queueFilter === 'all' ? '' : queueFilter,
+        status: statusFilter === 'all' ? '' : statusFilter as 'queued' | 'processing' | 'failed' | '',
+        search,
       })
 
-      const total = filtered.length
-      const start = (page - 1) * perPage
-      const data = filtered.slice(start, start + perPage)
-      const queues = Array.from(new Set(merged.map(j => j.queue))).sort()
-
-      return { data, total, page, perPage, queues, queueConnected: true }
+      return { data: result.data, total: result.total, page: result.page, perPage, queues: result.queues, queueConnected: true }
     }
     catch (error) {
       return dashboardOperationalError(error, 'Job history could not be loaded.', 'JobIndexAction')