@stacksjs/defaults 0.75.482 → 0.75.483

package/app/Actions/Dashboard/Jobs/job-list.ts

@@ -0,0 +1,168 @@
+import { db } from '@stacksjs/database/runtime'
+import type { DashboardJobStatus, ModelRecord, NormalizedJob } from './job-records'
+import { normalizeActiveJob, normalizeFailedJob, parseJobReference } from './job-records'
+
+/**
+ * One page of the Jobs list, read by the database (stacksjs/stacks#3201).
+ *
+ * Jobs live in two tables: `jobs`, waiting or reserved, and `failed_jobs`.
+ * The list used to read both whole and page them in memory. Now each is
+ * 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 and sliced. Deep pages read more, never more
+ * than the matching rows.
+ *
+ * Through `db` rather than the models: a model query's `whereLike` is a plain
+ * LIKE, which is case-sensitive on PostgreSQL, while `db` compares both sides
+ * lowercased on every dialect.
+ */
+
+export interface JobListQuery {
+  page: number
+  perPage: number
+  /** An exact queue, or empty for every queue. */
+  queue: string
+  status: DashboardJobStatus | ''
+  search: string
+}
+
+export interface JobListPage {
+  data: NormalizedJob[]
+  total: number
+  page: number
+  /** Every queue with a job or a failure, for the queue filter. */
+  queues: string[]
+}
+
+const STATES: DashboardJobStatus[] = ['queued', 'processing', 'failed']
+
+/** The states whose name holds the search, which the list always searched. */
+function statesNamed(term: string): Set<DashboardJobStatus> {
+  return new Set(term ? STATES.filter(state => state.includes(term)) : [])
+}
+
+/** An id the search names: `12`, or a reference such as `job-12`. */
+function idNamed(term: string, source: 'job' | 'failed'): number | null {
+  const reference = parseJobReference(term)
+  const id = reference.source === null || reference.source === source ? reference.id : ''
+  return /^\d+$/.test(id) ? Number(id) : null
+}
+
+/**
+ * A job is reserved when `reserved_at` is set and not 0, `queuedJobState`'s
+ * rule in `@stacksjs/queue`. The queue writes NULL or a timestamp, never 0.
+ */
+function activeQuery(query: JobListQuery): any | null {
+  if (query.status === 'failed')
+    return null
+
+  let chain: any = db.selectFrom('jobs')
+  if (query.queue)
+    chain = chain.where('queue', '=', query.queue)
+  if (query.status === 'processing')
+    chain = chain.whereNotNull('reserved_at').where('reserved_at', '!=', 0)
+  else if (query.status === 'queued')
+    chain = chain.whereGroup((group: any) => group.whereNull('reserved_at').orWhere('reserved_at', '=', 0))
+
+  const term = query.search.toLowerCase()
+  if (term) {
+    const states = statesNamed(term)
+    // Every waiting job's reference is `job-<id>`, so a search inside that
+    // word names them all, as it did when the reference itself was searched.
+    if ((states.has('queued') && states.has('processing')) || 'job-'.includes(term))
+      return chain
+    const id = idNamed(term, 'job')
+    chain = chain.whereGroup((group: any) => {
+      let match = group.whereLike('queue', `%${term}%`).orWhereLike('payload', `%${term}%`)
+      if (id !== null)
+        match = match.orWhere('id', '=', id)
+      if (states.has('queued'))
+        match = match.orWhereNull('reserved_at').orWhere('reserved_at', '=', 0)
+      if (states.has('processing'))
+        match = match.orWhere('reserved_at', '!=', 0)
+      return match
+    })
+  }
+  return chain
+}
+
+function failedQuery(query: JobListQuery): any | null {
+  if (query.status === 'queued' || query.status === 'processing')
+    return null
+
+  let chain: any = db.selectFrom('failed_jobs')
+  if (query.queue)
+    chain = chain.where('queue', '=', query.queue)
+
+  const term = query.search.toLowerCase()
+  if (term && !statesNamed(term).has('failed') && !'failed-'.includes(term)) {
+    const id = idNamed(term, 'failed')
+    chain = chain.whereGroup((group: any) => {
+      let match = group.whereLike('queue', `%${term}%`)
+        .orWhereLike('payload', `%${term}%`)
+        .orWhereLike('exception', `%${term}%`)
+        .orWhereLike('connection', `%${term}%`)
+      if (id !== null)
+        match = match.orWhere('id', '=', id)
+      return match
+    })
+  }
+  return chain
+}
+
+/** A row as the normalizers read a model record. */
+function asRecord(row: Record<string, unknown>): ModelRecord {
+  return { get: (key: string) => row[key] } as unknown as ModelRecord
+}
+
+async function countOf(chain: any | null): Promise<number> {
+  if (!chain)
+    return 0
+  const row = await chain.select(db.fn.count('id').as('count')).executeTakeFirst() as { count?: unknown } | undefined
+  return Number(row?.count ?? 0) || 0
+}
+
+async function newestRows(chain: any, limit: number): Promise<Record<string, unknown>[]> {
+  return await chain.selectAll().orderBy('created_at', 'desc').orderBy('id', 'desc').limit(limit).execute() as Record<string, unknown>[]
+}
+
+/** Newest first; at the same moment a waiting job before a failure, then the higher id, as before. */
+function newestFirst(a: NormalizedJob, b: NormalizedJob): number {
+  const byTime = new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
+  if (byTime !== 0)
+    return byTime
+  if (a.source !== b.source)
+    return a.source === 'job' ? -1 : 1
+  return Number(b.recordId) - Number(a.recordId)
+}
+
+export async function readJobPage(query: JobListQuery): Promise<JobListPage> {
+  const active = activeQuery(query)
+  const failed = failedQuery(query)
+
+  const [activeTotal, failedTotal, queueRows] = await Promise.all([
+    countOf(active),
+    countOf(failed),
+    db.unsafe('SELECT DISTINCT queue FROM jobs UNION SELECT DISTINCT queue FROM failed_jobs').execute() as Promise<Array<{ queue: unknown }>>,
+  ])
+
+  const total = activeTotal + failedTotal
+  const page = Math.min(query.page, Math.max(1, Math.ceil(total / query.perPage)))
+  const limit = page * query.perPage
+
+  const [activeRows, failedRows] = await Promise.all([
+    activeTotal > 0 ? newestRows(activeQuery(query), limit) : Promise.resolve([]),
+    failedTotal > 0 ? newestRows(failedQuery(query), limit) : Promise.resolve([]),
+  ])
+
+  const data = [...activeRows.map(row => normalizeActiveJob(asRecord(row))), ...failedRows.map(row => normalizeFailedJob(asRecord(row)))]
+    .sort(newestFirst)
+    .slice((page - 1) * query.perPage, limit)
+
+  return {
+    data,
+    total,
+    page,
+    queues: [...new Set(queueRows.map(row => String(row.queue ?? '')).filter(Boolean))].sort(),
+  }
+}

package/app/Actions/Dashboard/Jobs/job-records.ts

@@ -1,4 +1,5 @@
 import type { ReadableRecord } from '@stacksjs/orm'
+import { queuedJobState } from '@stacksjs/queue'
 export type JobRecordSource = 'job' | 'failed'
 export type DashboardJobStatus = 'queued' | 'processing' | 'failed'
 
@@ -154,6 +155,10 @@ export function normalizeActiveJob(record: ModelRecord): NormalizedJob {
   const payload = parsePayload(record.get('payload'))
   const queue = requiredString(record, 'queue')
   const reservedAt = timestampValue(record, 'reserved_at', 'Job', true)
+  // Reserved is `queuedJobState`'s rule: set and not 0. A 0 parsed as 1970
+  // and read as processing here while the queue and the stats called it
+  // waiting (stacksjs/stacks#3201).
+  const reserved = queuedJobState({ reserved_at: record.get('reserved_at'), available_at: record.get('available_at') }) === 'processing'
 
   return {
     id: jobReference('job', id),
@@ -162,7 +167,7 @@ export function normalizeActiveJob(record: ModelRecord): NormalizedJob {
     name: jobName(payload, queue),
     queue,
     connection: null,
-    status: reservedAt ? 'processing' : 'queued',
+    status: reserved ? 'processing' : 'queued',
     attempts: integerValue(record, 'attempts'),
     maxAttempts: payloadMaxAttempts(payload),
     duration: null,
@@ -171,8 +176,8 @@ export function normalizeActiveJob(record: ModelRecord): NormalizedJob {
     created_at: timestampValue(record, 'created_at')!,
     updated_at: timestampValue(record, 'updated_at', 'Job', true),
     available_at: timestampValue(record, 'available_at', 'Job', true),
-    reserved_at: reservedAt,
-    started_at: reservedAt,
+    reserved_at: reserved ? reservedAt : undefined,
+    started_at: reserved ? reservedAt : undefined,
   }
 }
 

package/app/Actions/Dashboard/Models/ModelShowAction.ts

@@ -269,11 +269,17 @@ export default new Action({
           chain = chain.where(column, value)
         }
         if (q && searchColumns.length > 0) {
+          // Lowercased on both sides, so the search ignores case on every
+          // dialect. A model query's whereLike is a plain LIKE, which is
+          // case-sensitive on PostgreSQL: "donald" did not find "Donald"
+          // there (stacksjs/stacks#3202). The column is one of the model's
+          // own (isSafeColumn), and the term is bound.
           chain = chain.whereGroup((group: any) => {
             for (const [index, column] of searchColumns.entries()) {
+              const match = `LOWER(${column}) LIKE LOWER(?)`
               group = index === 0
-                ? group.whereLike(column, `%${q}%`)
-                : group.orWhereLike(column, `%${q}%`)
+                ? group.whereRaw(match, `%${q}%`)
+                : group.orWhereRaw(match, `%${q}%`)
             }
             return group
           })

package/app/Actions/Dashboard/Queries/QueryDashboardAction.ts

@@ -1,29 +1,39 @@
+import type { RequestInstance } from '@stacksjs/types'
 import { Action } from '@stacksjs/actions/runtime'
 import { config } from '@stacksjs/config'
-import { db } from '@stacksjs/database/runtime'
+import { response } from '@stacksjs/router'
 import { dashboardOperationalError } from '../dashboard-response'
-import { dashboardQueryColumns, mapDashboardQueryLog, type QueryLogSourceRow } from './query-dashboard'
+import { parseQueryListQuery, readQueryLogPage } from './query-list'
 
+/**
+ * `GET /api/dashboard/queries`: one page of the query log for the Queries
+ * pages, with the counts their cards show. The range, filters and page are
+ * read by the database (`query-list.ts`, stacksjs/stacks#3204).
+ */
 export default new Action({
   name: 'Query Dashboard',
   description: 'Returns safe, native query log records for the operator dashboard.',
   method: 'GET',
   apiResponse: true,
 
-  async handle() {
+  async handle(request: RequestInstance) {
+    const query = parseQueryListQuery(key => request.get<unknown>(key, ''))
+    if ('error' in query)
+      return response.json({ message: query.error }, 422)
+
     const queryLogging = config.database?.queryLogging
     try {
-      const rows = await db
-        .selectFrom('query_logs')
-        .select(dashboardQueryColumns)
-        .orderBy('executed_at', 'desc')
-        .limit(2000)
-        .execute()
+      const result = await readQueryLogPage(query)
 
       return {
         enabled: queryLogging?.enabled === true,
         slowThreshold: queryLogging?.slowThreshold || 100,
-        queries: rows.map((row: unknown) => mapDashboardQueryLog(row as QueryLogSourceRow)),
+        queries: result.rows,
+        total: result.counts.total,
+        page: result.page,
+        perPage: query.perPage,
+        counts: result.counts,
+        connections: result.connections,
       }
     }
     catch (error) {

package/app/Actions/Dashboard/Queries/query-dashboard.ts

@@ -60,16 +60,56 @@ export interface DashboardQueryLog {
   suggestions: string[]
 }
 
+export const QUERY_TYPES = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'OTHER'] as const
+
+/** What `queryType` skips before the first word: ASCII whitespace, as SQL can strip it too. */
+const LEADING_SPACE = /^[ \t\n\v\f\r]+/
+
+/**
+ * The statement's kind, from its first word. `queryTypeSql` is the same rule
+ * in SQL, so the list can filter and count by kind in the database
+ * (stacksjs/stacks#3204); keep the two in step.
+ */
 export function queryType(query: string): DashboardQueryLog['type'] {
-  const type = query.trim().match(/^([a-z]+)/i)?.[1]?.toUpperCase()
+  const type = query.replace(LEADING_SPACE, '').match(/^([a-z]+)/i)?.[1]?.toUpperCase()
   return type === 'SELECT' || type === 'INSERT' || type === 'UPDATE' || type === 'DELETE'
     ? type
     : 'OTHER'
 }
 
-export function parseQueryLogList(value?: string | null, label = 'query log list'): string[] {
-  if (!value)
+const ASCII_LETTERS = Array.from({ length: 26 }, (_, index) => String.fromCharCode(65 + index))
+  .flatMap(letter => [letter, letter.toLowerCase()])
+  .map(letter => `'${letter}'`)
+  .join(', ')
+
+/**
+ * `queryType` as a SQL expression over `query_logs.query`, for one dialect.
+ *
+ * The text loses the same leading whitespace, then a kind matches when the
+ * text starts with its keyword in any case and the next character is not a
+ * letter, which is what `queryType`'s first-word match comes to. MySQL
+ * compares bytes here, because its default collation would also match
+ * accented letters.
+ */
+export function queryTypeSql(dialect: string): string {
+  const space = [9, 10, 11, 12, 13]
+  // MySQL's LTRIM strips spaces only. Its pattern holds the whitespace itself
+  // in a plain literal, which takes the column's collation where CHAR() would
+  // bring its own and be refused.
+  const text = dialect === 'mysql'
+    ? `REGEXP_REPLACE(query, '^[ ${space.map(code => String.fromCharCode(code)).join('')}]+', '')`
+    : `LTRIM(query, ' ' || ${space.map(code => `${dialect === 'postgres' ? 'chr' : 'char'}(${code})`).join(' || ')})`
+  const exact = (value: string): string => dialect === 'mysql' ? `CAST(${value} AS BINARY)` : value
+  const branches = QUERY_TYPES.filter(type => type !== 'OTHER').map(type =>
+    `WHEN ${exact(`UPPER(SUBSTR(${text}, 1, ${type.length}))`)} = '${type}' AND ${exact(`SUBSTR(${text}, ${type.length + 1}, 1)`)} NOT IN (${ASCII_LETTERS}) THEN '${type}'`)
+  return `(CASE ${branches.join(' ')} ELSE 'OTHER' END)`
+}
+
+export function parseQueryLogList(value?: unknown, label = 'query log list'): string[] {
+  if (value == null || value === '')
     return []
+  if (typeof value !== 'string')
+    throw new TypeError(`${label} must be JSON text`)
 
   let parsed: unknown
   try {
@@ -85,8 +125,15 @@ export function parseQueryLogList(value?: string | null, label = 'query log list
   return parsed
 }
 
-export function mapDashboardQueryLog(row: QueryLogSourceRow): DashboardQueryLog {
+export function mapDashboardQueryLog(row: QueryLogSourceRow | Record<string, unknown>): DashboardQueryLog {
   const label = `query log ${row.id}`
+  if (!((typeof row.id === 'number' && Number.isSafeInteger(row.id) && row.id > 0) || (typeof row.id === 'string' && row.id.trim())))
+    throw new TypeError('Query log id must be a positive integer or a non-empty string')
+  const text = (value: unknown, field: string): string => {
+    if (value == null) return ''
+    if (typeof value !== 'string') throw new TypeError(`${label} ${field} must be text or null`)
+    return value
+  }
   const status = queryStatus(row.status, label)
   if (typeof row.query !== 'string' || !row.query.trim())
     throw new TypeError(`${label} query must be a non-empty string`)
@@ -97,15 +144,15 @@ export function mapDashboardQueryLog(row: QueryLogSourceRow): DashboardQueryLog
   return {
     id: row.id,
     query: row.query,
-    normalizedQuery: row.normalized_query || row.query,
+    normalizedQuery: text(row.normalized_query, 'normalized query') || row.query,
     type: queryType(row.query),
     duration: finiteNumber(row.duration, `${label} duration`),
-    connection: row.connection || 'unknown',
+    connection: text(row.connection, 'connection') || 'unknown',
     status,
-    error: row.error || '',
+    error: text(row.error, 'error'),
     executedAt,
-    model: row.model || '',
-    method: row.method || '',
+    model: text(row.model, 'model'),
+    method: text(row.method, 'method'),
     rowsAffected: nullableFiniteNumber(row.rows_affected, `${label} rows_affected`),
     memoryUsage: nullableFiniteNumber(row.memory_usage, `${label} memory_usage`),
     tags: parseQueryLogList(row.tags, `${label} tags`),

package/app/Actions/Dashboard/Queries/query-list.ts

@@ -0,0 +1,161 @@
+import { db, getDatabaseDialect, sqlDateTime, sqlHelpers } from '@stacksjs/database/runtime'
+import type { QueryReader } from '../Content/content-list'
+import { countOf, LIST_PAGE_SIZES, pageWithin, queryText } from '../Content/content-list'
+import type { DashboardQueryLog } from './query-dashboard'
+import { dashboardQueryColumns, mapDashboardQueryLog, QUERY_TYPES, queryTypeSql } from './query-dashboard'
+
+/**
+ * One page of the query log, read by the database.
+ *
+ * The Queries pages used to fetch the newest 2,000 logs and filter, count and
+ * page those in the browser, so a week, or a slow query older than the
+ * newest 2,000, was simply not there (stacksjs/stacks#3204). Now the range,
+ * filters, counts and page are all SQL.
+ */
+
+export const QUERY_RANGES = { hour: 1, day: 24, week: 168 } as const
+export const QUERY_STATUSES = ['completed', 'slow', 'failed'] as const
+
+export type QueryRange = keyof typeof QUERY_RANGES
+export type QueryStatus = typeof QUERY_STATUSES[number]
+
+export interface QueryListQuery {
+  range: QueryRange
+  status: QueryStatus | 'all'
+  type: DashboardQueryLog['type'] | 'all'
+  connection: string
+  page: number
+  perPage: number
+}
+
+export interface QueryCounts {
+  total: number
+  reads: number
+  writes: number
+  slow: number
+  failed: number
+  /** Mean duration in milliseconds, 0 when nothing matched. */
+  averageDuration: number
+}
+
+export interface QueryLogPage {
+  rows: DashboardQueryLog[]
+  /** The page the rows are, moved back to the last one when it ran past it. */
+  page: number
+  /** Counts over every log matching the range and filters; `total` is what the pager counts. */
+  counts: QueryCounts
+  /** The connections that logged anything in the range, for the connection filter. */
+  connections: string[]
+}
+
+/** The range, filters and page, or the reason they are invalid. Absent values take the page's defaults. */
+export function parseQueryListQuery(read: QueryReader): QueryListQuery | { error: string } {
+  const range = queryText(read, 'range') || 'day'
+  if (!Object.hasOwn(QUERY_RANGES, range))
+    return { error: `range must be one of ${Object.keys(QUERY_RANGES).join(', ')}.` }
+
+  const status = queryText(read, 'status') || 'all'
+  if (status !== 'all' && !(QUERY_STATUSES as readonly string[]).includes(status))
+    return { error: `status must be all or one of ${QUERY_STATUSES.join(', ')}.` }
+
+  const type = queryText(read, 'type') || 'all'
+  if (type !== 'all' && !(QUERY_TYPES as readonly string[]).includes(type))
+    return { error: `type must be all or one of ${QUERY_TYPES.join(', ')}.` }
+
+  const connection = queryText(read, 'connection')
+  if (connection.length > 200)
+    return { error: 'connection must be 200 characters or fewer.' }
+
+  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 === '' ? 50 : Number(sizeText)
+  if (!(LIST_PAGE_SIZES as readonly number[]).includes(perPage))
+    return { error: `per_page must be one of ${LIST_PAGE_SIZES.join(', ')}.` }
+
+  return {
+    range: range as QueryRange,
+    status: status as QueryListQuery['status'],
+    type: type as QueryListQuery['type'],
+    connection,
+    page,
+    perPage,
+  }
+}
+
+/** The earliest `executed_at` in the range, in the form the query logger writes it. */
+export function rangeStart(range: QueryRange, now: number = Date.now()): string {
+  return sqlDateTime(new Date(now - QUERY_RANGES[range] * 3_600_000))
+}
+
+/**
+ * The WHERE clause for a query, every value bound. The range alone is the
+ * connection filter's scope, so it is built separately.
+ */
+function where(query: QueryListQuery, now: number): { range: { sql: string, values: unknown[] }, all: { sql: string, values: unknown[] } } {
+  const dialect = getDatabaseDialect()
+  const helpers = sqlHelpers(dialect)
+  const values: unknown[] = []
+  const bind = (value: unknown): string => {
+    values.push(value)
+    return helpers.param(values.length)
+  }
+
+  const clauses = [`executed_at >= ${bind(rangeStart(query.range, now))}`]
+  const range = { sql: `WHERE ${clauses[0]}`, values: [...values] }
+  if (query.status !== 'all')
+    clauses.push(`status = ${bind(query.status)}`)
+  if (query.type !== 'all')
+    clauses.push(`${queryTypeSql(dialect)} = ${bind(query.type)}`)
+  if (query.connection)
+    clauses.push(`connection = ${bind(query.connection)}`)
+
+  return { range, all: { sql: `WHERE ${clauses.join(' AND ')}`, values } }
+}
+
+export async function readQueryLogPage(query: QueryListQuery, now: number = Date.now()): Promise<QueryLogPage> {
+  const type = queryTypeSql(getDatabaseDialect())
+  const filter = where(query, now)
+
+  const [[counted], connectionRows] = await Promise.all([
+    db.unsafe(
+      `SELECT COUNT(*) AS total_count,
+        SUM(CASE WHEN ${type} = 'SELECT' THEN 1 ELSE 0 END) AS read_count,
+        SUM(CASE WHEN ${type} IN ('INSERT', 'UPDATE', 'DELETE') THEN 1 ELSE 0 END) AS write_count,
+        SUM(CASE WHEN status = 'slow' THEN 1 ELSE 0 END) AS slow_count,
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed_count,
+        AVG(duration) AS average_duration
+       FROM query_logs ${filter.all.sql}`,
+      filter.all.values,
+    ).execute(),
+    db.unsafe(`SELECT DISTINCT connection FROM query_logs ${filter.range.sql} ORDER BY connection`, filter.range.values).execute() as Promise<Array<{ connection: unknown }>>,
+  ])
+
+  const counts: QueryCounts = {
+    total: countOf(counted?.total_count),
+    reads: countOf(counted?.read_count),
+    writes: countOf(counted?.write_count),
+    slow: countOf(counted?.slow_count),
+    failed: countOf(counted?.failed_count),
+    averageDuration: countOf(counted?.average_duration),
+  }
+
+  const page = pageWithin(query.page, counts.total, query.perPage)
+  const rows = counts.total === 0
+    ? []
+    : await db.unsafe(
+      `SELECT ${dashboardQueryColumns.join(', ')} FROM query_logs ${filter.all.sql}
+       ORDER BY executed_at DESC, id DESC LIMIT ${Math.trunc(query.perPage)} OFFSET ${Math.trunc((page - 1) * query.perPage)}`,
+      filter.all.values,
+    ).execute()
+
+  return {
+    rows: rows.map(row => mapDashboardQueryLog(row)),
+    page,
+    counts,
+    connections: connectionRows.map(row => String(row.connection ?? 'unknown')),
+  }
+}

package/app/Actions/Dashboard/Queue/QueueStatsAction.ts

@@ -1,15 +1,8 @@
 import { Action } from '@stacksjs/actions/runtime'
 import { FailedJob, Job } from '@stacksjs/orm'
-import { getGlobalMetrics, queuedJobState } from '@stacksjs/queue'
+import { getGlobalMetrics } from '@stacksjs/queue'
 import { dashboardOperationalError } from '../dashboard-response'
-
-interface QueueBucket {
-  pending: number
-  active: number
-  completed: number
-  failed: number
-  total: number
-}
+import { readQueueCounts } from './queue-stats'
 
 // A queued job has no `status` column - `queuedJobState` in @stacksjs/queue
 // holds the rule (reserved_at means a worker has it; available_at in the
@@ -23,54 +16,23 @@ export default new Action({
   method: 'GET',
   async handle() {
     try {
-      const [totalJobs, failedJobCount, allJobs, allFailedJobs] = await Promise.all([
+      const [totalJobs, failedJobCount, counts] = await Promise.all([
         Job.count(),
         FailedJob.count(),
-        Job.all(),
-        FailedJob.all(),
+        readQueueCounts(),
       ])
 
-      const queueMap: Record<string, QueueBucket> = {}
-
-      // Per-queue failure counts come from failed_jobs, which is where a
-      // failure actually lands. This column read `status === 'failed'` off the
-      // jobs table before, and so was always zero.
-      const failedByQueue = new Map<string, number>()
-      for (const f of allFailedJobs) {
-        const queueName = String(f.get('queue') || 'default')
-        failedByQueue.set(queueName, (failedByQueue.get(queueName) ?? 0) + 1)
-      }
-      let active = 0
-      const completed = 0
-
-      for (const j of allJobs) {
-        const queueName = String(j.get('queue') || 'default')
-        const status = queuedJobState({ reserved_at: j.get('reserved_at'), available_at: j.get('available_at') })
-
-        if (!queueMap[queueName]) {
-          queueMap[queueName] = { pending: 0, active: 0, completed: 0, failed: 0, total: 0 }
-        }
-        const bucket = queueMap[queueName]
-        bucket.total++
-
-        if (status === 'processing') {
-          bucket.active++
-          active++
-        }
-        else {
-          bucket.pending++
-        }
-      }
-
-      const queues = Object.entries(queueMap).map(([name, data]) => ({
-        name,
-        status: data.active > 0 ? 'active' : 'idle',
-        pending: data.pending,
-        active: data.active,
-        completed: data.completed,
-        failed: failedByQueue.get(name) ?? data.failed,
-        total: data.total,
+      const queues = counts.map(queue => ({
+        name: queue.name,
+        status: queue.active > 0 ? 'active' : 'idle',
+        pending: queue.pending,
+        active: queue.active,
+        completed: 0,
+        failed: queue.failed,
+        total: queue.total,
       }))
+      const active = counts.reduce((sum, queue) => sum + queue.active, 0)
+      const completed = 0
 
       // The in-memory metrics tracker only sees jobs processed since the
       // current API process started, so it complements (not replaces) the DB