adonisjs-server-stats 1.9.0 → 1.10.3

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

@@ -0,0 +1,17 @@
+/**
+ * Lazily loads and caches static assets (CSS, JS, transmit client)
+ * needed for the dashboard page.
+ *
+ * Extracted from DashboardController to reduce file size and complexity.
+ */
+export declare class DashboardPageAssets {
+    private cachedCss;
+    private cachedJs;
+    private cachedTransmitClient;
+    /** Load and cache the combined CSS bundle. */
+    getCss(): string;
+    /** Load and cache the dashboard JS bundle for the given renderer. */
+    getJs(renderer: string): string;
+    /** Load and cache the transmit client, or return empty string. */
+    getTransmitClient(packageJsonPath: string): string;
+}

package/dist/src/dashboard/dashboard_page_assets.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { log } from '../utils/logger.js';
+import { loadTransmitClient } from '../utils/transmit_client.js';
+const SRC_DIR = dirname(fileURLToPath(import.meta.url));
+const EDGE_DIR = join(SRC_DIR, '..', 'edge');
+const STYLES_DIR = join(SRC_DIR, '..', 'styles');
+/**
+ * Lazily loads and caches static assets (CSS, JS, transmit client)
+ * needed for the dashboard page.
+ *
+ * Extracted from DashboardController to reduce file size and complexity.
+ */
+export class DashboardPageAssets {
+    cachedCss = null;
+    cachedJs = null;
+    cachedTransmitClient = null;
+    /** Load and cache the combined CSS bundle. */
+    getCss() {
+        if (!this.cachedCss) {
+            const tokens = readFileSync(join(STYLES_DIR, 'tokens.css'), 'utf-8');
+            const components = readFileSync(join(STYLES_DIR, 'components.css'), 'utf-8');
+            const utilities = readFileSync(join(STYLES_DIR, 'utilities.css'), 'utf-8');
+            const dashboard = readFileSync(join(STYLES_DIR, 'dashboard.css'), 'utf-8');
+            this.cachedCss = tokens + '\n' + components + '\n' + utilities + '\n' + dashboard;
+        }
+        return this.cachedCss;
+    }
+    /** Load and cache the dashboard JS bundle for the given renderer. */
+    getJs(renderer) {
+        if (!this.cachedJs) {
+            const clientDir = renderer === 'vue' ? 'client-vue' : 'client';
+            this.cachedJs = readFileSync(join(EDGE_DIR, clientDir, 'dashboard.js'), 'utf-8');
+        }
+        return this.cachedJs;
+    }
+    /** Load and cache the transmit client, or return empty string. */
+    getTransmitClient(packageJsonPath) {
+        if (this.cachedTransmitClient === null) {
+            this.cachedTransmitClient = loadTransmitClient(packageJsonPath);
+            if (this.cachedTransmitClient) {
+                log.info('Transmit client loaded for dashboard');
+            }
+            else {
+                log.info('Dashboard will use polling. Install @adonisjs/transmit-client for real-time updates.');
+            }
+        }
+        return this.cachedTransmitClient;
+    }
+}

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

@@ -1,90 +1,8 @@
-import type { DevToolbarConfig } from '../debug/types.js';
-import type { QueryRecord, EventRecord, EmailRecord, TraceRecord } from '../debug/types.js';
+import type { DevToolbarConfig, EventRecord, EmailRecord } from '../debug/types.js';
+import type { StorageStatsResult } from './storage_stats.js';
 import type { Knex } from 'knex';
-interface EventEmitter {
-    on(event: string, handler: (...args: unknown[]) => void): void;
-    off(event: string, handler: (...args: unknown[]) => void): void;
-}
-export interface RequestInput {
-    method: string;
-    url: string;
-    statusCode: number;
-    duration: number;
-    spanCount?: number;
-    warningCount?: number;
-}
-export interface PersistRequestInput extends RequestInput {
-    queries: QueryRecord[];
-    trace: TraceRecord | null;
-}
-export interface RequestFilters {
-    method?: string;
-    url?: string;
-    status?: number;
-    statusMin?: number;
-    statusMax?: number;
-    durationMin?: number;
-    durationMax?: number;
-    /** General text search across method and url */
-    search?: string;
-}
-export interface QueryFilters {
-    method?: string;
-    model?: string;
-    connection?: string;
-    durationMin?: number;
-    durationMax?: number;
-    requestId?: number;
-    /** General text search across sql_text, model, and connection */
-    search?: string;
-}
-export interface EventFilters {
-    eventName?: string;
-    /** General text search across event_name */
-    search?: string;
-}
-export interface EmailFilters {
-    /** General text search across from_addr, to_addr, and subject */
-    search?: string;
-    from?: string;
-    to?: string;
-    subject?: string;
-    mailer?: string;
-    status?: string;
-}
-export interface LogFilters {
-    level?: string;
-    requestId?: string;
-    search?: string;
-    /** Structured filters: array of { field, operator, value } */
-    structured?: {
-        field: string;
-        operator: 'equals' | 'contains' | 'startsWith';
-        value: string;
-    }[];
-}
-export interface TraceFilters {
-    method?: string;
-    url?: string;
-    statusMin?: number;
-    statusMax?: number;
-    /** General text search across method and url */
-    search?: string;
-}
-export interface PaginatedResult<T> {
-    data: T[];
-    total: number;
-    page: number;
-    perPage: number;
-    lastPage: number;
-}
-/**
- * Bridges the in-memory RingBuffer collectors to SQLite persistence
- * and provides query methods for the dashboard API.
- *
- * Handles auto-migration, retention cleanup, periodic metrics aggregation,
- * and self-exclusion of dashboard routes and server_stats connection queries.
- */
+export type { RequestInput, PersistRequestInput, RequestFilters, QueryFilters, EventFilters, EmailFilters, LogFilters, TraceFilters, PaginatedResult, PaginateOptions, } from './dashboard_types.js';
+import type { EventEmitter, PersistRequestInput, RequestFilters, QueryFilters, EventFilters, EmailFilters, LogFilters, TraceFilters, PaginatedResult } from './dashboard_types.js';
 export declare class DashboardStore {
     private db;
     private emitter;
@@ -95,133 +13,37 @@ export declare class DashboardStore {
     private handlers;
     private dbFilePath;
     private lastCleanupAt;
-    private inflight;
-    private coalesce;
-    private resultCache;
-    private cached;
+    private cache;
     private cachedStorageStats;
-    private static readonly STORAGE_STATS_TTL_MS;
-    private static readonly WIDGETS_CACHE_TTL_MS;
-    private static readonly SPARKLINE_CACHE_TTL_MS;
-    private static readonly CHART_CACHE_TTL_MS;
-    private static readonly QUERIES_GROUPED_CACHE_TTL_MS;
-    private static readonly PAGINATE_CACHE_TTL_MS;
-    private writeQueue;
-    private pendingEvents;
-    private pendingLogs;
-    private pendingEmails;
-    private flushTimer;
-    private flushing;
-    private static readonly FLUSH_INTERVAL_MS;
-    private static readonly MAX_QUEUE_SIZE;
+    private flushMgr;
+    private static readonly STORAGE_TTL;
     constructor(config: DevToolbarConfig);
-    /**
-     * Initialize the SQLite connection, run migrations and retention
-     * cleanup, start chart aggregation, and wire event listeners.
-     */
     start(_lucidDb: unknown, emitter: EventEmitter | null, appRoot: string): Promise<void>;
-    /** Shut down timers, event listeners, and database connection. */
+    private initMigrations;
     stop(): Promise<void>;
-    /** Get the raw Knex database connection (for DashboardController). */
+    private removeListeners;
     getDb(): Knex | null;
-    /** Whether the store is initialized and ready. */
     isReady(): boolean;
-    /**
-     * Get SQLite storage statistics for the diagnostics endpoint.
-     * Cached for 10s since the Internals tab polls every 3s.
-     * Wrapped in a single transaction — 1 pool acquire instead of 8.
-     */
-    getStorageStats(): Promise<{
-        ready: boolean;
-        dbPath: string;
-        fileSizeMb: number;
-        walSizeMb: number;
-        retentionDays: number;
-        tables: Array<{
-            name: string;
-            rowCount: number;
-        }>;
-        lastCleanupAt: number | null;
-    }>;
-    /**
-     * Queue a full request (with queries, events, trace) for batch persistence.
-     * Returns null immediately — actual IDs are assigned during flush.
-     *
-     * Writes are buffered and flushed every 500ms in a single transaction,
-     * which prevents the single-connection pool from being overwhelmed by
-     * individual fire-and-forget INSERT calls under load.
-     */
+    getStorageStats(): Promise<StorageStatsResult>;
     persistRequest(input: PersistRequestInput): Promise<number | null>;
-    /** Queue events to be attached to a request during flush. */
     queueEvents(requestIndex: number, events: EventRecord[]): void;
-    /** Record a single log entry — queued for batch flush. */
     recordLog(entry: Record<string, unknown>): void;
-    /** Record a single email — queued for batch flush (avoids bypassing the write queue). */
     recordEmail(record: EmailRecord): void;
-    /** Schedule the next batch flush if not already scheduled. */
-    private scheduleFlush;
-    /**
-     * Flush all pending writes in a single transaction.
-     *
-     * A transaction acquires the pool connection ONCE, runs all INSERTs
-     * (synchronous via better-sqlite3), then releases. Without a
-     * transaction, each INSERT does its own async acquire/release cycle —
-     * under load this creates hundreds of microtasks that starve the
-     * event loop and freeze the server.
-     */
-    private flushWriteQueue;
-    /** Paginated request history with optional filters. */
-    getRequests(page?: number, perPage?: number, filters?: RequestFilters): Promise<PaginatedResult<Record<string, unknown>>>;
-    /** Paginated query history with optional filters. */
-    getQueries(page?: number, perPage?: number, filters?: QueryFilters): Promise<PaginatedResult<Record<string, unknown>>>;
-    /**
-     * Grouped query patterns: aggregated by sql_normalized
-     * with count, avg/min/max/total duration.
-     */
+    flushWriteQueue(): Promise<void>;
+    private get readCtx();
+    getRequests(p?: number, pp?: number, f?: RequestFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+    getQueries(p?: number, pp?: number, f?: QueryFilters): Promise<PaginatedResult<Record<string, unknown>>>;
     getQueriesGrouped(limit?: number, sort?: string, search?: string): Promise<Record<string, unknown>[]>;
-    /** Paginated event history with optional filters. */
-    getEvents(page?: number, perPage?: number, filters?: EventFilters): Promise<PaginatedResult<Record<string, unknown>>>;
-    /** Paginated email history with optional filters. */
-    getEmails(page?: number, perPage?: number, filters?: EmailFilters, excludeBody?: boolean): Promise<PaginatedResult<Record<string, unknown>>>;
-    /** Get email HTML body for preview (falls back to text_body). */
+    getEvents(p?: number, pp?: number, f?: EventFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+    getEmails(p?: number, pp?: number, f?: EmailFilters, excludeBody?: boolean): Promise<PaginatedResult<Record<string, unknown>>>;
     getEmailHtml(id: number): Promise<string | null>;
-    /**
-     * Paginated log history with structured search support.
-     *
-     * Structured filters query into the JSON `data` column using
-     * SQLite's `json_extract()`.
-     */
-    getLogs(page?: number, perPage?: number, filters?: LogFilters): Promise<PaginatedResult<Record<string, unknown>>>;
-    /** Paginated trace history with optional filters. */
-    getTraces(page?: number, perPage?: number, filters?: TraceFilters): Promise<PaginatedResult<Record<string, unknown>>>;
-    /** Single trace with full span data. */
+    getLogs(p?: number, pp?: number, f?: LogFilters): Promise<PaginatedResult<Record<string, unknown>>>;
+    getTraces(p?: number, pp?: number, f?: TraceFilters): Promise<PaginatedResult<Record<string, unknown>>>;
     getTraceDetail(id: number): Promise<Record<string, unknown> | null>;
-    /**
-     * Single request with associated queries, events, and trace.
-     * Wrapped in a transaction — 1 pool acquire instead of 4.
-     */
     getRequestDetail(id: number): Promise<Record<string, unknown> | null>;
-    /**
-     * Aggregated overview metrics for the dashboard cards.
-     *
-     * @param range — '1h' | '6h' | '24h' | '7d'
-     */
-    /**
-     * Wrapped in a single transaction — 1 pool acquire instead of 5.
-     */
     getOverviewMetrics(range?: string): Promise<Record<string, unknown> | null>;
-    /**
-     * Time-series chart data from server_stats_metrics.
-     *
-     * @param range — '1h' | '6h' | '24h' | '7d'
-     */
     getChartData(range?: string): Promise<Record<string, unknown>[]>;
-    /**
-     * Widget data for the dashboard overview.
-     *
-     * @param range — '1h' | '6h' | '24h' | '7d'
-     */
-    getOverviewWidgets(range?: string): Promise<{
+    getOverviewWidgets(range?: string): Promise<import("./overview_store_queries.js").OverviewWidgets | {
         topEvents: {
             eventName: string;
             count: number;
@@ -249,30 +71,10 @@ export declare class DashboardStore {
             count: number;
         }[];
     }>;
-    /** Get sparkline data points from pre-aggregated metrics. */
     getSparklineData(range: string): Promise<Record<string, unknown>[]>;
     getSavedFilters(section?: string): Promise<Record<string, unknown>[]>;
     createSavedFilter(name: string, section: string, filterConfig: Record<string, unknown>): Promise<Record<string, unknown> | null>;
     deleteSavedFilter(id: number): Promise<boolean>;
-    /**
-     * Run EXPLAIN on a stored query using the app's default database connection.
-     * Only allows SELECT queries for safety.
-     *
-     * @param queryId — ID from server_stats_queries
-     * @param appDb — The application's Lucid database manager
-     */
     runExplain(queryId: number, appDb: unknown): Promise<Record<string, unknown> | null>;
-    /**
-     * Generic paginated query with filter callback.
-     *
-     * Wrapped in a single transaction so COUNT + SELECT acquire the pool
-     * connection only once instead of two separate acquire/release cycles.
-     * With max:1 pool, this halves pool pressure per paginated endpoint.
-     */
-    private paginate;
-    /**
-     * Wire email event listeners to persist emails as they arrive.
-     */
     private wireEventListeners;
 }
-export {};