adonisjs-server-stats 1.10.0 → 1.10.3

package/dist/src/dashboard/overview_queries.js

@@ -0,0 +1,155 @@
+/**
+ * Pure data-mapping helpers for dashboard overview and chart queries.
+ *
+ * These functions transform raw database rows into the shapes
+ * expected by the dashboard API. No I/O — just mapping and math.
+ */
+import { round } from '../utils/math_helpers.js';
+import { rangeToMinutes, roundBucket } from '../utils/time_helpers.js';
+const EMPTY_OVERVIEW = {
+    avgResponseTime: 0,
+    p95ResponseTime: 0,
+    requestsPerMinute: 0,
+    errorRate: 0,
+    totalRequests: 0,
+    slowestEndpoints: [],
+    queryStats: { total: 0, avgDuration: 0, perRequest: 0 },
+    recentErrors: [],
+};
+function mapQueryStats(queryStats, total) {
+    const qTotal = queryStats?.total ?? 0;
+    return {
+        total: qTotal,
+        avgDuration: queryStats?.avg_duration ?? 0,
+        perRequest: total > 0 ? round(qTotal / total) : 0,
+    };
+}
+export function buildOverviewResult(input) {
+    const { total, stats, range, slowestEndpoints, queryStats, recentErrors } = input;
+    if (total === 0)
+        return EMPTY_OVERVIEW;
+    const errorCount = Number(stats?.error_count ?? 0);
+    return {
+        avgResponseTime: round(stats?.avg_duration ?? 0),
+        p95ResponseTime: 0,
+        requestsPerMinute: round(total / rangeToMinutes(range)),
+        errorRate: round((errorCount / total) * 100),
+        totalRequests: total,
+        slowestEndpoints: slowestEndpoints.map((s) => ({
+            url: s.url,
+            count: s.count,
+            avgDuration: s.avg_duration,
+        })),
+        queryStats: mapQueryStats(queryStats, total),
+        recentErrors: recentErrors.map((e) => ({
+            id: e.id,
+            message: e.message,
+            createdAt: e.created_at,
+        })),
+    };
+}
+// ---------------------------------------------------------------------------
+// Widget data mappers
+// ---------------------------------------------------------------------------
+/**
+ * Map raw top events rows to the widget shape.
+ */
+export function mapTopEvents(raw) {
+    return (raw || []).map((r) => ({
+        eventName: r.event_name,
+        count: r.count,
+    }));
+}
+/**
+ * Aggregate email status rows into sent/queued/failed counts.
+ */
+export function mapEmailActivity(raw) {
+    const activity = { sent: 0, queued: 0, failed: 0 };
+    for (const row of raw || []) {
+        const status = row.status;
+        const count = row.count;
+        if (status === 'sent' || status === 'sending')
+            activity.sent += count;
+        else if (status === 'queued' || status === 'queueing')
+            activity.queued += count;
+        else if (status === 'failed')
+            activity.failed = count;
+    }
+    return activity;
+}
+/**
+ * Map log level rows to the breakdown shape.
+ */
+export function mapLogLevelBreakdown(raw) {
+    const breakdown = { error: 0, warn: 0, info: 0, debug: 0 };
+    for (const row of raw || []) {
+        const level = row.level;
+        if (level in breakdown) {
+            breakdown[level] = row.count;
+        }
+    }
+    return breakdown;
+}
+/**
+ * Map status distribution row to the widget shape.
+ */
+export function mapStatusDistribution(row) {
+    return {
+        '2xx': row?.s2xx ?? 0,
+        '3xx': row?.s3xx ?? 0,
+        '4xx': row?.s4xx ?? 0,
+        '5xx': row?.s5xx ?? 0,
+    };
+}
+/**
+ * Map slowest query rows to the widget shape.
+ */
+export function mapSlowestQueries(raw) {
+    return (raw || []).map((r) => ({
+        sqlNormalized: r.sql_normalized,
+        avgDuration: r.avg_duration,
+        count: r.count,
+    }));
+}
+/**
+ * Aggregate per-minute metrics into larger buckets for 24h/7d ranges.
+ * For 1h/6h, rows are returned as-is.
+ */
+export function aggregateChartBuckets(rows, range) {
+    if (range === '1h' || range === '6h')
+        return rows;
+    const bucketMinutes = range === '7d' ? 60 : 15;
+    const grouped = new Map();
+    for (const row of rows) {
+        const bucketKey = roundBucket(row.bucket, bucketMinutes);
+        if (!grouped.has(bucketKey)) {
+            grouped.set(bucketKey, {
+                bucket: bucketKey,
+                request_count: 0,
+                avg_duration: 0,
+                p95_duration: 0,
+                error_count: 0,
+                query_count: 0,
+                avg_query_duration: 0,
+                _count: 0,
+            });
+        }
+        const g = grouped.get(bucketKey);
+        g.request_count += row.request_count;
+        g.error_count += row.error_count;
+        g.query_count += row.query_count;
+        g.avg_duration += row.avg_duration;
+        g.p95_duration = Math.max(g.p95_duration, row.p95_duration);
+        g.avg_query_duration += row.avg_query_duration;
+        g._count++;
+    }
+    return Array.from(grouped.values()).map((g) => ({
+        bucket: g.bucket,
+        request_count: g.request_count,
+        avg_duration: g._count > 0 ? round(g.avg_duration / g._count) : 0,
+        p95_duration: round(g.p95_duration),
+        error_count: g.error_count,
+        query_count: g.query_count,
+        avg_query_duration: g._count > 0 ? round(g.avg_query_duration / g._count) : 0,
+    }));
+}

package/dist/src/dashboard/overview_query_runners.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Database query runners for overview metrics and widget data.
+ *
+ * These functions execute the actual Knex queries within transactions.
+ * Extracted from DashboardStore to reduce file length.
+ */
+import type { Knex } from 'knex';
+/**
+ * Query aggregated overview metrics within a transaction.
+ */
+export declare function queryOverviewMetrics(trx: Knex.Transaction, cutoff: string, range: string): Promise<Record<string, unknown>>;
+/**
+ * Raw widget data shape returned by queryWidgetData.
+ */
+export interface WidgetDataRaw {
+    topEventsRaw: Record<string, unknown>[];
+    emailStatusRaw: Record<string, unknown>[];
+    logLevelsRaw: Record<string, unknown>[];
+    statusRaw: Record<string, unknown> | undefined;
+    slowQueriesRaw: Record<string, unknown>[];
+}
+/**
+ * Query all widget data in a single transaction.
+ */
+export declare function queryWidgetData(db: Knex, cutoff: string): Promise<WidgetDataRaw>;

package/dist/src/dashboard/overview_query_runners.js

@@ -0,0 +1,84 @@
+/**
+ * Database query runners for overview metrics and widget data.
+ *
+ * These functions execute the actual Knex queries within transactions.
+ * Extracted from DashboardStore to reduce file length.
+ */
+import { round } from '../utils/math_helpers.js';
+import { buildOverviewResult } from './overview_queries.js';
+/**
+ * Query aggregated overview metrics within a transaction.
+ */
+export async function queryOverviewMetrics(trx, cutoff, range) {
+    const stats = await trx('server_stats_requests')
+        .where('created_at', '>=', cutoff)
+        .select(trx.raw('COUNT(*) as total'), trx.raw('ROUND(AVG(duration), 2) as avg_duration'), trx.raw('SUM(CASE WHEN status_code >= 400 THEN 1 ELSE 0 END) as error_count'))
+        .first();
+    const total = Number(stats?.total ?? 0);
+    const slowestEndpoints = await trx('server_stats_requests')
+        .where('created_at', '>=', cutoff)
+        .select('url', trx.raw('COUNT(*) as count'), trx.raw('ROUND(AVG(duration), 2) as avg_duration'))
+        .groupBy('url')
+        .orderBy('avg_duration', 'desc')
+        .limit(5);
+    const queryStats = await trx('server_stats_queries')
+        .where('created_at', '>=', cutoff)
+        .select(trx.raw('COUNT(*) as total'), trx.raw('ROUND(AVG(duration), 2) as avg_duration'))
+        .first();
+    const recentErrors = await trx('server_stats_logs')
+        .where('created_at', '>=', cutoff)
+        .whereIn('level', ['error', 'fatal'])
+        .orderBy('created_at', 'desc')
+        .limit(5);
+    const result = buildOverviewResult({
+        total,
+        stats,
+        range,
+        slowestEndpoints,
+        queryStats,
+        recentErrors,
+    });
+    if (total > 0) {
+        const p95Offset = Math.floor(total * 0.95);
+        const p95Row = await trx('server_stats_requests')
+            .where('created_at', '>=', cutoff)
+            .orderBy('duration', 'asc')
+            .offset(Math.min(p95Offset, total - 1))
+            .limit(1)
+            .select('duration')
+            .first();
+        result.p95ResponseTime = round(p95Row?.duration ?? 0);
+    }
+    return result;
+}
+/**
+ * Query all widget data in a single transaction.
+ */
+export async function queryWidgetData(db, cutoff) {
+    return db.transaction(async (trx) => ({
+        topEventsRaw: await trx('server_stats_events')
+            .select('event_name', trx.raw('COUNT(*) as count'))
+            .where('created_at', '>=', cutoff)
+            .groupBy('event_name')
+            .orderBy('count', 'desc')
+            .limit(5),
+        emailStatusRaw: await trx('server_stats_emails')
+            .select('status', trx.raw('COUNT(*) as count'))
+            .where('created_at', '>=', cutoff)
+            .groupBy('status'),
+        logLevelsRaw: await trx('server_stats_logs')
+            .select('level', trx.raw('COUNT(*) as count'))
+            .where('created_at', '>=', cutoff)
+            .groupBy('level'),
+        statusRaw: await trx('server_stats_requests')
+            .select(trx.raw(`SUM(CASE WHEN status_code >= 200 AND status_code < 300 THEN 1 ELSE 0 END) as "s2xx"`), trx.raw(`SUM(CASE WHEN status_code >= 300 AND status_code < 400 THEN 1 ELSE 0 END) as "s3xx"`), trx.raw(`SUM(CASE WHEN status_code >= 400 AND status_code < 500 THEN 1 ELSE 0 END) as "s4xx"`), trx.raw(`SUM(CASE WHEN status_code >= 500 AND status_code < 600 THEN 1 ELSE 0 END) as "s5xx"`))
+            .where('created_at', '>=', cutoff)
+            .first(),
+        slowQueriesRaw: await trx('server_stats_queries')
+            .select('sql_normalized', trx.raw('ROUND(AVG(duration), 2) as avg_duration'), trx.raw('COUNT(*) as count'))
+            .where('created_at', '>=', cutoff)
+            .groupBy('sql_normalized')
+            .orderBy('avg_duration', 'desc')
+            .limit(5),
+    }));
+}

package/dist/src/dashboard/overview_store_queries.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Overview, chart, widget, and sparkline queries for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ * All functions take a Knex instance and CoalesceCache as parameters.
+ */
+import { CoalesceCache } from './coalesce_cache.js';
+import type { Knex } from 'knex';
+export declare function fetchOverviewMetrics(db: Knex, cache: CoalesceCache, range: string): Promise<Record<string, unknown> | null>;
+export declare function fetchChartData(db: Knex, cache: CoalesceCache, range: string): Promise<Record<string, unknown>[]>;
+export interface OverviewWidgets {
+    topEvents: {
+        eventName: string;
+        count: number;
+    }[];
+    emailActivity: {
+        sent: number;
+        queued: number;
+        failed: number;
+    };
+    logLevelBreakdown: {
+        error: number;
+        warn: number;
+        info: number;
+        debug: number;
+    };
+    statusDistribution: {
+        '2xx': number;
+        '3xx': number;
+        '4xx': number;
+        '5xx': number;
+    };
+    slowestQueries: {
+        sqlNormalized: string;
+        avgDuration: number;
+        count: number;
+    }[];
+}
+export declare function fetchOverviewWidgets(db: Knex, cache: CoalesceCache, range: string): Promise<OverviewWidgets>;
+export declare function fetchSparklineData(db: Knex, cache: CoalesceCache, range: string): Promise<Record<string, unknown>[]>;

package/dist/src/dashboard/overview_store_queries.js

@@ -0,0 +1,69 @@
+/**
+ * Overview, chart, widget, and sparkline queries for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ * All functions take a Knex instance and CoalesceCache as parameters.
+ */
+import { log } from '../utils/logger.js';
+import { rangeToCutoff } from '../utils/time_helpers.js';
+import { mapTopEvents, mapEmailActivity, mapLogLevelBreakdown, mapStatusDistribution, mapSlowestQueries, aggregateChartBuckets, } from './overview_queries.js';
+import { queryOverviewMetrics, queryWidgetData } from './overview_query_runners.js';
+const WIDGETS_TTL = 2_000;
+const SPARKLINE_TTL = 5_000;
+const CHART_TTL = 5_000;
+let overviewWidgetWarned = false;
+// ---------------------------------------------------------------------------
+// Overview metrics
+// ---------------------------------------------------------------------------
+export function fetchOverviewMetrics(db, cache, range) {
+    return cache.cached('overviewMetrics:' + range, 2_000, () => db.transaction((trx) => queryOverviewMetrics(trx, rangeToCutoff(range), range)));
+}
+// ---------------------------------------------------------------------------
+// Chart data
+// ---------------------------------------------------------------------------
+export function fetchChartData(db, cache, range) {
+    return cache.cached('chartData:' + range, CHART_TTL, async () => {
+        const rows = await db('server_stats_metrics')
+            .where('bucket', '>=', rangeToCutoff(range))
+            .orderBy('bucket', 'asc');
+        return aggregateChartBuckets(rows, range);
+    });
+}
+const EMPTY_WIDGETS = {
+    topEvents: [],
+    emailActivity: { sent: 0, queued: 0, failed: 0 },
+    logLevelBreakdown: { error: 0, warn: 0, info: 0, debug: 0 },
+    statusDistribution: { '2xx': 0, '3xx': 0, '4xx': 0, '5xx': 0 },
+    slowestQueries: [],
+};
+export function fetchOverviewWidgets(db, cache, range) {
+    return cache.cached('overviewWidgets:' + range, WIDGETS_TTL, async () => {
+        try {
+            const raw = await queryWidgetData(db, rangeToCutoff(range));
+            return {
+                topEvents: mapTopEvents(raw.topEventsRaw),
+                emailActivity: mapEmailActivity(raw.emailStatusRaw),
+                logLevelBreakdown: mapLogLevelBreakdown(raw.logLevelsRaw),
+                statusDistribution: mapStatusDistribution(raw.statusRaw),
+                slowestQueries: mapSlowestQueries(raw.slowQueriesRaw),
+            };
+        }
+        catch (err) {
+            if (!overviewWidgetWarned) {
+                overviewWidgetWarned = true;
+                log.warn('dashboard: getOverviewWidgets query failed — ' + err?.message);
+            }
+            return EMPTY_WIDGETS;
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Sparkline data
+// ---------------------------------------------------------------------------
+export function fetchSparklineData(db, cache, range) {
+    return cache.cached('sparkline:' + range, SPARKLINE_TTL, async () => {
+        return (await db('server_stats_metrics')
+            .where('bucket', '>=', rangeToCutoff(range))
+            .orderBy('bucket', 'asc')).slice(-15);
+    });
+}

package/dist/src/dashboard/paginate_helper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generic paginated query helper.
+ *
+ * Wraps COUNT + SELECT in a single transaction so the pool connection
+ * is acquired only once instead of two separate acquire/release cycles.
+ */
+import type { PaginatedResult, PaginateOptions } from './dashboard_types.js';
+import type { Knex } from 'knex';
+/**
+ * Execute a paginated query within a transaction.
+ */
+export declare function executePaginate(db: Knex, opts: PaginateOptions): Promise<PaginatedResult<Record<string, unknown>>>;

package/dist/src/dashboard/paginate_helper.js

@@ -0,0 +1,33 @@
+/**
+ * Generic paginated query helper.
+ *
+ * Wraps COUNT + SELECT in a single transaction so the pool connection
+ * is acquired only once instead of two separate acquire/release cycles.
+ */
+/**
+ * Execute a paginated query within a transaction.
+ */
+export async function executePaginate(db, opts) {
+    return db.transaction(async (trx) => {
+        const countQuery = trx(opts.table);
+        if (opts.applyFilters)
+            opts.applyFilters(countQuery);
+        const [{ count: totalRaw }] = await countQuery.count('* as count');
+        const total = Number(totalRaw);
+        const offset = (opts.page - 1) * opts.perPage;
+        const dataQuery = trx(opts.table)
+            .orderBy('created_at', 'desc')
+            .limit(opts.perPage)
+            .offset(offset);
+        if (opts.applyFilters)
+            opts.applyFilters(dataQuery);
+        const data = await dataQuery;
+        return {
+            data,
+            total,
+            page: opts.page,
+            perPage: opts.perPage,
+            lastPage: Math.ceil(total / opts.perPage),
+        };
+    });
+}

package/dist/src/dashboard/query_explain_handler.d.ts

@@ -0,0 +1,10 @@
+import type { DashboardStore } from './dashboard_store.js';
+import type { HttpContext } from '@adonisjs/core/http';
+import type { ApplicationService } from '@adonisjs/core/types';
+/**
+ * Handle the EXPLAIN endpoint for a stored query.
+ *
+ * Extracted from DashboardController.queryExplain to reduce
+ * complexity and function length.
+ */
+export declare function handleQueryExplain(dashboardStore: DashboardStore, app: ApplicationService, ctx: HttpContext): Promise<unknown>;

package/dist/src/dashboard/query_explain_handler.js

@@ -0,0 +1,80 @@
+/**
+ * Fetch and validate the query record for EXPLAIN.
+ * Returns null and sends an error response if invalid.
+ */
+async function fetchQueryRecord(dashboardStore, id) {
+    const db = dashboardStore.getDb();
+    if (!db)
+        return null;
+    return db('server_stats_queries').where('id', id).first() ?? null;
+}
+/** Check if the SQL is a SELECT statement (required for EXPLAIN). */
+function isSelectQuery(sqlText) {
+    return sqlText.trim().toUpperCase().startsWith('SELECT');
+}
+/** Parse bindings from a stored query. */
+function parseBindings(raw) {
+    if (!raw)
+        return [];
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+/** Get the Lucid write client for running EXPLAIN. */
+async function getAppDbClient(app) {
+    try {
+        const lucid = await app.container.make('lucid.db');
+        return lucid
+            .connection()
+            .getWriteClient();
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract the plan from raw EXPLAIN result. */
+function extractPlan(explainResult) {
+    const rawRows = explainResult?.rows ??
+        (Array.isArray(explainResult) ? explainResult : []);
+    if (rawRows.length > 0 && rawRows[0]['QUERY PLAN']) {
+        return rawRows[0]['QUERY PLAN'];
+    }
+    return rawRows;
+}
+/**
+ * Handle the EXPLAIN endpoint for a stored query.
+ *
+ * Extracted from DashboardController.queryExplain to reduce
+ * complexity and function length.
+ */
+export async function handleQueryExplain(dashboardStore, app, ctx) {
+    const { params, response } = ctx;
+    if (!dashboardStore.isReady()) {
+        return response.notFound({ error: 'Not found' });
+    }
+    try {
+        const query = await fetchQueryRecord(dashboardStore, Number(params.id));
+        if (!query)
+            return response.notFound({ error: 'Query not found' });
+        if (!isSelectQuery(query.sql_text)) {
+            return response.badRequest({ error: 'EXPLAIN is only supported for SELECT queries' });
+        }
+        const appDb = await getAppDbClient(app);
+        if (!appDb) {
+            return response.serviceUnavailable({ error: 'App database connection not available' });
+        }
+        const bindings = parseBindings(query.bindings);
+        const explainResult = await appDb.raw(`EXPLAIN (FORMAT JSON) ${query.sql_text}`, bindings);
+        const plan = extractPlan(explainResult);
+        return response.json({ queryId: Number(params.id), sql: query.sql_text, plan });
+    }
+    catch (error) {
+        return response.internalServerError({
+            error: 'EXPLAIN failed',
+            message: error?.message ?? 'Unknown error',
+        });
+    }
+}

package/dist/src/dashboard/read_queries.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Paginated and detail read queries for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ */
+import type { CoalesceCache } from './coalesce_cache.js';
+import type { RequestFilters, QueryFilters, EventFilters, EmailFilters, LogFilters, TraceFilters, PaginatedResult } from './dashboard_types.js';
+import type { Knex } from 'knex';
+interface ReadCtx {
+    db: Knex;
+    cache: CoalesceCache;
+}
+export declare function queryRequests(ctx: ReadCtx, page: number, perPage: number, filters?: RequestFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryQueries(ctx: ReadCtx, page: number, perPage: number, filters?: QueryFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryEvents(ctx: ReadCtx, page: number, perPage: number, filters?: EventFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryEmails(ctx: ReadCtx, opts: {
+    page: number;
+    perPage: number;
+    filters?: EmailFilters;
+    excludeBody?: boolean;
+}): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryLogs(ctx: ReadCtx, page: number, perPage: number, filters?: LogFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryTraces(ctx: ReadCtx, page: number, perPage: number, filters?: TraceFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+export declare function queryQueriesGrouped(ctx: ReadCtx, opts: {
+    limit: number;
+    sort: string;
+    search?: string;
+}): Promise<Record<string, unknown>[]>;
+export declare function queryEmailHtml(ctx: ReadCtx, id: number): Promise<string | null>;
+export declare function queryTraceDetail(ctx: ReadCtx, id: number): Promise<Record<string, unknown> | null>;
+export declare function queryRequestDetail(ctx: ReadCtx, id: number): Promise<Record<string, unknown> | null>;
+export {};

package/dist/src/dashboard/read_queries.js

@@ -0,0 +1,107 @@
+/**
+ * Paginated and detail read queries for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ */
+import { rangeToCutoff } from '../utils/time_helpers.js';
+import { fetchTraceDetail, fetchRequestDetail } from './detail_queries.js';
+import { applyRequestFilters, applyQueryFilters, applyEventFilters, applyEmailFilters, applyLogFilters, applyTraceFilters, } from './filtered_queries.js';
+import { executePaginate } from './paginate_helper.js';
+const GROUPED_TTL = 3_000;
+const PAGINATE_TTL = 1_000;
+export function queryRequests(ctx, page, perPage, filters) {
+    return paginateCached(ctx, {
+        table: 'server_stats_requests',
+        page,
+        perPage,
+        applyFilters: (q) => applyRequestFilters(q, filters),
+        filterKey: filters ? JSON.stringify(filters) : '',
+    });
+}
+export function queryQueries(ctx, page, perPage, filters) {
+    return paginateCached(ctx, {
+        table: 'server_stats_queries',
+        page,
+        perPage,
+        applyFilters: (q) => applyQueryFilters(q, filters),
+        filterKey: filters ? JSON.stringify(filters) : '',
+    });
+}
+export function queryEvents(ctx, page, perPage, filters) {
+    return paginateCached(ctx, {
+        table: 'server_stats_events',
+        page,
+        perPage,
+        applyFilters: (q) => applyEventFilters(q, filters),
+        filterKey: filters ? JSON.stringify(filters) : '',
+    });
+}
+export function queryEmails(ctx, opts) {
+    const { page, perPage, filters, excludeBody = false } = opts;
+    return paginateCached(ctx, {
+        table: 'server_stats_emails',
+        page,
+        perPage,
+        applyFilters: (q) => applyEmailFilters(q, filters, excludeBody),
+        filterKey: (filters ? JSON.stringify(filters) : '') + (excludeBody ? ':noBody' : ''),
+    });
+}
+export function queryLogs(ctx, page, perPage, filters) {
+    return paginateCached(ctx, {
+        table: 'server_stats_logs',
+        page,
+        perPage,
+        applyFilters: (q) => applyLogFilters(q, filters),
+        filterKey: filters ? JSON.stringify(filters) : '',
+    });
+}
+export function queryTraces(ctx, page, perPage, filters) {
+    return paginateCached(ctx, {
+        table: 'server_stats_traces',
+        page,
+        perPage,
+        applyFilters: (q) => applyTraceFilters(q, filters),
+        filterKey: filters ? JSON.stringify(filters) : '',
+    });
+}
+export function queryQueriesGrouped(ctx, opts) {
+    const { db, cache } = ctx;
+    const { limit, sort, search } = opts;
+    return cache.cached('queriesGrouped:' + limit + ':' + sort + ':' + (search || ''), GROUPED_TTL, async () => {
+        const sorts = {
+            count: 'count',
+            avg_duration: 'avg_duration',
+            total_duration: 'total_duration',
+        };
+        const cutoff = rangeToCutoff('7d');
+        const q = db('server_stats_queries')
+            .select('sql_normalized', db.raw('COUNT(*) as count'), db.raw('ROUND(AVG(duration), 2) as avg_duration'), db.raw('ROUND(MIN(duration), 2) as min_duration'), db.raw('ROUND(MAX(duration), 2) as max_duration'), db.raw('ROUND(SUM(duration), 2) as total_duration'))
+            .where('created_at', '>=', cutoff)
+            .groupBy('sql_normalized')
+            .orderBy(sorts[sort] || 'total_duration', 'desc')
+            .limit(limit);
+        if (search)
+            q.where('sql_normalized', 'like', `%${search}%`);
+        return q;
+    });
+}
+export function queryEmailHtml(ctx, id) {
+    return ctx.cache.coalesce('emailHtml:' + id, async () => {
+        const row = await ctx
+            .db('server_stats_emails')
+            .where('id', id)
+            .select('html', 'text_body')
+            .first();
+        return row ? row.html || row.text_body || null : null;
+    });
+}
+export function queryTraceDetail(ctx, id) {
+    return ctx.cache.coalesce('traceDetail:' + id, () => fetchTraceDetail(ctx.db, id));
+}
+export function queryRequestDetail(ctx, id) {
+    return ctx.cache.coalesce('requestDetail:' + id, () => fetchRequestDetail(ctx.db, id));
+}
+function paginateCached(ctx, opts) {
+    const key = 'paginate:' + opts.table + ':' + opts.page + ':' + opts.perPage + ':' + (opts.filterKey || '');
+    return ctx.cache.cached(key, PAGINATE_TTL, () => executePaginate(ctx.db, opts));
+}

package/dist/src/dashboard/saved_filter_queries.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Saved filter CRUD operations for the DashboardStore.
+ *
+ * Extracted from DashboardStore to reduce file length.
+ */
+import { CoalesceCache } from './coalesce_cache.js';
+import type { Knex } from 'knex';
+export declare function fetchSavedFilters(db: Knex, cache: CoalesceCache, section?: string): Promise<Record<string, unknown>[]>;
+export declare function insertSavedFilter(db: Knex, name: string, section: string, filterConfig: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function removeSavedFilter(db: Knex, id: number): Promise<boolean>;