adonisjs-server-stats 1.5.3 → 1.6.1

package/dist/src/provider/server_stats_provider.js

@@ -1,11 +1,13 @@
-import { registerDashboardRoutes } from '../dashboard/dashboard_routes.js';
+import { readFileSync } from 'node:fs';
+import { getLogStreamService } from '../collectors/log_collector.js';
 import { DashboardStore } from '../dashboard/dashboard_store.js';
+import { DataAccess } from '../data/data_access.js';
 import { DebugStore } from '../debug/debug_store.js';
 import { StatsEngine } from '../engine/stats_engine.js';
 import { LogStreamService } from '../log_stream/log_stream_service.js';
 import { setShouldShow, setTraceCollector, setDashboardPath, setExcludedPrefixes, setOnRequestComplete, } from '../middleware/request_tracking_middleware.js';
-import { registerDebugRoutes } from '../routes/debug_routes.js';
-import { registerStatsRoutes } from '../routes/stats_routes.js';
+import { registerAllRoutes } from '../routes/register_routes.js';
+import { log, dim, bold } from '../utils/logger.js';
 export default class ServerStatsProvider {
     app;
     intervalId = null;
@@ -20,6 +22,15 @@ export default class ServerStatsProvider {
     flushTimer = null;
     statsController = null;
     debugController = null;
+    apiController = null;
+    // Diagnostics tracking
+    pinoHookActive = false;
+    edgePluginActive = false;
+    prometheusActive = false;
+    transmitAvailable = false;
+    transmitChannels = [];
+    resolvedConfig = null;
+    resolvedCollectors = [];
     constructor(app) {
         this.app = app;
     }
@@ -40,37 +51,68 @@ export default class ServerStatsProvider {
         }
         if (router && !this.app.inProduction) {
             const registeredPaths = [];
-            // ── Auto-register stats bar endpoint ───────────────────────
-            if (typeof config.endpoint === 'string') {
-                registerStatsRoutes(router, config.endpoint, () => this.statsController, config.shouldShow);
-                registeredPaths.push(config.endpoint);
-            }
-            // ── Auto-register debug toolbar routes ─────────────────────
+            const r = router;
             const toolbarConfig = config.devToolbar;
-            if (toolbarConfig?.enabled) {
-                const debugEndpoint = toolbarConfig.debugEndpoint ?? '/admin/api/debug';
-                registerDebugRoutes(router, debugEndpoint, () => this.debugController, config.shouldShow);
+            // Derive endpoint paths for route registration
+            const statsEndpoint = typeof config.endpoint === 'string' ? config.endpoint : false;
+            const debugEndpoint = toolbarConfig?.enabled
+                ? (toolbarConfig.debugEndpoint ?? '/admin/api/debug')
+                : undefined;
+            const dashboardPath = toolbarConfig?.enabled && toolbarConfig.dashboard
+                ? (toolbarConfig.dashboardPath ?? '/__stats')
+                : undefined;
+            // ── Register all routes via the unified registrar ──────────
+            registerAllRoutes({
+                router: r,
+                getApiController: () => this.apiController,
+                getStatsController: () => this.statsController,
+                getDebugController: () => this.debugController,
+                getDashboardController: () => this.dashboardController,
+                statsEndpoint,
+                debugEndpoint,
+                dashboardPath,
+                shouldShow: config.shouldShow,
+            });
+            // Track which paths were registered for logging
+            if (typeof statsEndpoint === 'string') {
+                registeredPaths.push(statsEndpoint);
+            }
+            if (debugEndpoint) {
                 registeredPaths.push(debugEndpoint + '/*');
-                // ── Auto-register dashboard routes ─────────────────────────
-                if (toolbarConfig.dashboard) {
-                    const dashPath = toolbarConfig.dashboardPath ?? '/__stats';
-                    registerDashboardRoutes(router, dashPath, () => this.dashboardController, config.shouldShow);
-                    registeredPaths.push(dashPath + '/*');
-                }
+            }
+            if (dashboardPath) {
+                registeredPaths.push(dashboardPath + '/*');
             }
             // Log registered routes
             if (registeredPaths.length > 0) {
-                const tag = '\x1b[36m[ \x1b[1m🔍 server-stats\x1b[0m\x1b[36m ]\x1b[0m';
-                const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-                const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-                console.log(`\n${tag} routes registered:\n` +
-                    registeredPaths.map((p) => `  ${dim('→')} ${bold(p)}`).join('\n') +
-                    '\n\n' +
-                    `${tag} ${dim('heads up — these routes get polled every ~3s.')}\n` +
-                    `  ${dim('global middleware (like silentAuth) runs on every poll,')}\n` +
-                    `  ${dim('which means extra DB queries. two ways to fix this:')}\n` +
-                    `  ${dim('1. move auth middleware to a route group (not server.use)')}\n` +
-                    `  ${dim('2. use the shouldShow callback in config for access control')}\n`);
+                log.list('routes registered:', registeredPaths);
+                // Only warn about global auth middleware if:
+                // 1. shouldShow is NOT configured (user hasn't set up access control)
+                // 2. There IS auth middleware in server.use() or router.use()
+                if (!config.shouldShow) {
+                    const authMiddleware = this.detectGlobalAuthMiddleware();
+                    if (authMiddleware.length > 0) {
+                        log.block(bold('found global auth middleware that will run on every poll:'), [
+                            ...authMiddleware.map((m) => `${dim('→')} ${m}`),
+                            '',
+                            dim('these routes get polled every ~3s, so auth middleware will'),
+                            dim('trigger a DB query on each poll. here are two ways to fix it:'),
+                            '',
+                            `${bold('option 1:')} add a shouldShow callback to your config:`,
+                            '',
+                            dim('// config/server_stats.ts'),
+                            dim("shouldShow: (ctx) => ctx.auth?.user?.role === 'admin'"),
+                            '',
+                            `${bold('option 2:')} move auth middleware from router.use() to a route group:`,
+                            '',
+                            dim('// start/kernel.ts — remove from router.use()'),
+                            dim("// () => import('#middleware/silent_auth_middleware')"),
+                            '',
+                            dim('// start/routes.ts — add to your route groups instead'),
+                            dim('router.group(() => { ... }).use(middleware.silentAuth())'),
+                        ]);
+                    }
+                }
             }
         }
         if (!this.app.usingEdgeJS)
@@ -79,10 +121,106 @@ export default class ServerStatsProvider {
             const edge = await import('edge.js');
             const { edgePluginServerStats } = await import('../edge/plugin.js');
             edge.default.use(edgePluginServerStats(config));
+            this.edgePluginActive = true;
+        }
+        catch (err) {
+            log.warn('could not register Edge plugin — @serverStats() tag will not work: ' +
+                err?.message);
+        }
+    }
+    /**
+     * Read start/kernel.ts and detect auth-related middleware in server.use()
+     * or router.use() blocks. Returns import paths of problematic middleware.
+     *
+     * Ignores initialize_auth_middleware (no DB query — just sets up ctx.auth).
+     */
+    detectGlobalAuthMiddleware() {
+        const found = [];
+        try {
+            // Try both .ts and .js extensions
+            let source = '';
+            for (const ext of ['ts', 'js']) {
+                try {
+                    source = readFileSync(this.app.makePath('start', `kernel.${ext}`), 'utf-8');
+                    if (source)
+                        break;
+                }
+                catch {
+                    // Try next extension
+                }
+            }
+            if (!source)
+                return found;
+            // Extract server.use([...]) and router.use([...]) blocks
+            const useBlockRegex = /(?:server|router)\.use\(\s*\[([\s\S]*?)\]\s*\)/g;
+            let match;
+            while ((match = useBlockRegex.exec(source)) !== null) {
+                const block = match[1];
+                // Find all import paths in this block
+                const importRegex = /import\(\s*['"]([^'"]+)['"]\s*\)/g;
+                let importMatch;
+                while ((importMatch = importRegex.exec(block)) !== null) {
+                    const importPath = importMatch[1];
+                    // Skip initialize_auth_middleware — it just sets up ctx.auth, no DB query
+                    if (importPath.includes('initialize_auth'))
+                        continue;
+                    // Detect auth-related middleware
+                    if (importPath.includes('auth') ||
+                        importPath.includes('silent_auth') ||
+                        importPath.includes('silentAuth')) {
+                        found.push(importPath);
+                    }
+                }
+            }
         }
         catch {
-            // Edge not available — skip tag registration
+            // Can't read kernel file — skip detection
         }
+        return found;
+    }
+    /**
+     * Hook into the AdonisJS logger's Pino stream to feed log entries
+     * directly into the LogStreamService — no file path needed.
+     *
+     * Uses `Symbol.for('pino.stream')` (documented Pino API) to access
+     * the underlying destination stream, then wraps its `write` method
+     * to tee entries into the log collector.
+     */
+    async hookPinoLogger() {
+        const logStream = getLogStreamService();
+        if (!logStream)
+            return; // logCollector() not in the config
+        let logger;
+        try {
+            logger = await this.app.container.make('logger');
+        }
+        catch {
+            // Logger not available
+        }
+        const pino = logger?.pino;
+        if (!pino)
+            return;
+        const streamSym = Symbol.for('pino.stream');
+        const rawStream = pino[streamSym];
+        if (!rawStream || typeof rawStream.write !== 'function')
+            return;
+        const stream = rawStream;
+        const originalWrite = stream.write.bind(stream);
+        stream.write = function (chunk, ...args) {
+            try {
+                const str = typeof chunk === 'string' ? chunk : chunk.toString();
+                const entry = JSON.parse(str);
+                if (entry && typeof entry.level === 'number') {
+                    logStream.ingest(entry);
+                }
+            }
+            catch {
+                // Not valid JSON — ignore (e.g. pino-pretty output)
+            }
+            return originalWrite(chunk, ...args);
+        };
+        this.pinoHookActive = true;
+        log.info('log collector hooked into AdonisJS logger (zero-config)');
     }
     async ready() {
         const config = this.app.config.get('server_stats');
@@ -90,9 +228,23 @@ export default class ServerStatsProvider {
             return;
         if (this.app.inTest && config.skipInTest !== false)
             return;
-        this.engine = new StatsEngine(config.collectors);
+        this.resolvedConfig = config;
+        let collectors;
+        if (!config.collectors || config.collectors === 'auto') {
+            const { autoDetectCollectors } = await import('../collectors/auto_detect.js');
+            const result = await autoDetectCollectors();
+            collectors = result.collectors;
+            log.info(`${bold(String(result.active))} of ${bold(String(result.total))} collectors active`);
+        }
+        else {
+            collectors = config.collectors;
+        }
+        this.resolvedCollectors = collectors;
+        this.engine = new StatsEngine(collectors);
         this.app.container.singleton('server_stats.engine', () => this.engine);
         await this.engine.start();
+        // Auto-hook log collector into the AdonisJS Pino logger (zero-config)
+        await this.hookPinoLogger();
         // Create the stats controller (makes the stats route functional)
         const StatsControllerClass = (await import('../controller/server_stats_controller.js')).default;
         this.statsController = new StatsControllerClass(this.engine);
@@ -125,14 +277,27 @@ export default class ServerStatsProvider {
             if (prefixes.length > 0) {
                 setExcludedPrefixes(prefixes);
             }
+            // Create the unified ApiController now that both stores are available
+            if (this.debugStore) {
+                const logPath = this.app.makePath('logs', 'adonisjs.log');
+                const dataAccess = new DataAccess(this.debugStore, this.dashboardStore, logPath);
+                const { ApiController: ApiControllerClass } = await import('../controller/api_controller.js');
+                this.apiController = new ApiControllerClass(dataAccess);
+            }
         }
         let transmit = null;
         if (config.transport === 'transmit') {
             try {
                 transmit = await this.app.container.make('transmit');
+                if (transmit) {
+                    this.transmitAvailable = true;
+                    if (config.channelName) {
+                        this.transmitChannels.push(config.channelName);
+                    }
+                }
             }
             catch {
-                // Transmit not installed — skip broadcasting
+                log.info('transport is "transmit" but @adonisjs/transmit is not installed — falling back to polling');
             }
         }
         let prometheusCollector = null;
@@ -141,15 +306,21 @@ export default class ServerStatsProvider {
             prometheusCollector = mod.ServerStatsCollector.instance;
         }
         catch {
-            // Prometheus not installed — skip
+            // Prometheus not installed — skip (optional dependency)
+        }
+        if (prometheusCollector) {
+            this.prometheusActive = true;
+            log.info('Prometheus integration active');
         }
         this.intervalId = setInterval(async () => {
             try {
                 const stats = await this.engine.collect();
                 if (transmit && config.channelName) {
+                    ;
                     transmit.broadcast(config.channelName, JSON.parse(JSON.stringify(stats)));
                 }
                 if (prometheusCollector) {
+                    ;
                     prometheusCollector.update(stats);
                 }
                 config.onStats?.(stats);
@@ -176,7 +347,7 @@ export default class ServerStatsProvider {
             emitter = await this.app.container.make('emitter');
         }
         catch {
-            // Emitter not available
+            log.warn('AdonisJS emitter not available — query and event collection will be disabled');
         }
         // Get the router
         let router = null;
@@ -188,9 +359,13 @@ export default class ServerStatsProvider {
         }
         await this.debugStore.start(emitter, router);
         // Create the debug controller (makes the debug routes functional)
-        const logPath = this.app.makePath('logs', 'adonisjs.log');
+        const serverConfig = this.app.config.get('server_stats');
         const DebugControllerClass = (await import('../controller/debug_controller.js')).default;
-        this.debugController = new DebugControllerClass(this.debugStore, logPath);
+        this.debugController = new DebugControllerClass(this.debugStore, serverConfig, {
+            getEngine: () => this.engine,
+            getDashboardStore: () => this.dashboardStore,
+            getProviderDiagnostics: () => this.getDiagnostics(),
+        });
         // Wire trace collector into the request tracking middleware
         if (this.debugStore.traces) {
             setTraceCollector(this.debugStore.traces);
@@ -215,7 +390,11 @@ export default class ServerStatsProvider {
             // Transmit not installed — debug panel will use polling
         }
         if (debugTransmit) {
+            this.transmitAvailable = true;
             const debugChannel = 'server-stats/debug';
+            if (!this.transmitChannels.includes(debugChannel)) {
+                this.transmitChannels.push(debugChannel);
+            }
             const pendingTypes = new Set();
             this.debugStore.onNewItem((type) => {
                 // Debounce: coalesce rapid events into a single broadcast
@@ -227,6 +406,7 @@ export default class ServerStatsProvider {
                     const types = Array.from(pendingTypes);
                     pendingTypes.clear();
                     try {
+                        ;
                         debugTransmit.broadcast(debugChannel, { types });
                     }
                     catch {
@@ -257,9 +437,9 @@ export default class ServerStatsProvider {
         catch (err) {
             const msg = err?.message || '';
             if (msg.includes('better-sqlite3') || msg.includes('Cannot find module')) {
-                console.warn('[server-stats] Dashboard requires better-sqlite3. Install it with:\n' +
+                log.warn('Dashboard requires better-sqlite3. Install it with:\n' +
                     '  npm install better-sqlite3\n' +
-                    'Dashboard has been disabled for this session.');
+                    '  Dashboard has been disabled for this session.');
                 this.dashboardStore = null;
                 return;
             }
@@ -272,18 +452,33 @@ export default class ServerStatsProvider {
         setDashboardPath(toolbarConfig.dashboardPath);
         // Create the controller — this makes the routes registered in boot() functional
         const DashboardControllerClass = (await import('../dashboard/dashboard_controller.js')).default;
-        this.dashboardController = new DashboardControllerClass(this.dashboardStore, this.debugStore, this.app);
+        this.dashboardController = new DashboardControllerClass(this.dashboardStore, this.app);
         // ── Log piping ────────────────────────────────────────────────
-        const logPath = this.app.makePath('logs', 'adonisjs.log');
-        this.dashboardLogStream = new LogStreamService(logPath, (entry) => {
-            this.dashboardStore?.recordLog(entry);
-        });
-        await this.dashboardLogStream.start();
+        // If the log collector is already hooked into Pino (zero-config mode),
+        // piggyback on it instead of creating a separate file poller.
+        const existingLogStream = getLogStreamService();
+        if (existingLogStream && !existingLogStream['logPath']) {
+            // Stream mode — add a listener for dashboard persistence
+            const origOnEntry = existingLogStream['onEntry'];
+            existingLogStream['onEntry'] = (entry) => {
+                origOnEntry?.(entry);
+                this.dashboardStore?.recordLog(entry);
+            };
+        }
+        else {
+            // File-based fallback
+            const logPath = this.app.makePath('logs', 'adonisjs.log');
+            this.dashboardLogStream = new LogStreamService(logPath, (entry) => {
+                this.dashboardStore?.recordLog(entry);
+            });
+            await this.dashboardLogStream.start();
+        }
         // ── Per-request data piping ────────────────────────────────────
         const debugStore = this.debugStore;
         const dashStore = this.dashboardStore;
         let lastQueryId = 0;
         let lastEventId = 0;
+        let warnedPersistOnce = false;
         setOnRequestComplete(({ method, url, statusCode, duration, trace }) => {
             if (!dashStore.isReady())
                 return;
@@ -301,14 +496,24 @@ export default class ServerStatsProvider {
             }
             // Persist asynchronously (fire-and-forget)
             dashStore
-                .persistRequest(method, url, statusCode, duration, newQueries, trace ?? null)
+                .persistRequest({
+                method,
+                url,
+                statusCode,
+                duration,
+                queries: newQueries,
+                trace: trace ?? null,
+            })
                 .then((requestId) => {
                 if (requestId !== null && newEvents.length > 0) {
                     return dashStore.recordEvents(requestId, newEvents);
                 }
             })
-                .catch(() => {
-                // Silently ignore persistence errors
+                .catch((err) => {
+                if (!warnedPersistOnce) {
+                    warnedPersistOnce = true;
+                    log.warn('failed to persist request data — ' + (err?.message || 'unknown error'));
+                }
             });
         });
         // ── Transmit streaming for real-time dashboard updates ────────
@@ -320,13 +525,24 @@ export default class ServerStatsProvider {
             // Transmit not installed — skip real-time updates
         }
         if (transmit) {
+            this.transmitAvailable = true;
             const dashChannel = 'server-stats/dashboard';
+            if (!this.transmitChannels.includes(dashChannel)) {
+                this.transmitChannels.push(dashChannel);
+            }
             this.dashboardBroadcastTimer = setInterval(async () => {
                 try {
                     if (!dashStore.isReady())
                         return;
                     const overview = await dashStore.getOverviewMetrics('1h');
-                    transmit.broadcast(dashChannel, overview);
+                    const diagnostics = {
+                        collectors: this.engine.getCollectorHealth(),
+                        buffers: this.debugStore.getBufferStats(),
+                    };
+                    transmit.broadcast(dashChannel, {
+                        ...overview,
+                        diagnostics,
+                    });
                 }
                 catch {
                     // Silently ignore
@@ -334,6 +550,80 @@ export default class ServerStatsProvider {
             }, 5_000);
         }
     }
+    /** Return diagnostics state for the Internals endpoint. */
+    getDiagnostics() {
+        const config = this.resolvedConfig;
+        const toolbarConfig = config?.devToolbar;
+        return {
+            timers: {
+                collectionInterval: {
+                    active: this.intervalId !== null,
+                    intervalMs: config?.intervalMs ?? 0,
+                },
+                dashboardBroadcast: {
+                    active: this.dashboardBroadcastTimer !== null,
+                    intervalMs: 5000,
+                },
+                debugBroadcast: {
+                    active: this.debugBroadcastTimer !== null,
+                    debounceMs: 200,
+                },
+                persistFlush: {
+                    active: this.flushTimer !== null,
+                    intervalMs: 30_000,
+                },
+                retentionCleanup: {
+                    active: this.dashboardStore?.isReady() ?? false,
+                    intervalMs: 60 * 60 * 1000,
+                },
+            },
+            transmit: {
+                available: this.transmitAvailable,
+                channels: this.transmitChannels,
+            },
+            integrations: {
+                prometheus: { active: this.prometheusActive },
+                pinoHook: {
+                    active: this.pinoHookActive,
+                    mode: this.pinoHookActive ? 'stream' : toolbarConfig?.enabled ? 'none' : 'none',
+                },
+                edgePlugin: { active: this.edgePluginActive },
+                cacheInspector: {
+                    available: this.resolvedCollectors.some((c) => c.name === 'redis'),
+                },
+                queueInspector: {
+                    available: this.resolvedCollectors.some((c) => c.name === 'queue'),
+                },
+            },
+            config: {
+                intervalMs: config?.intervalMs ?? 0,
+                transport: config?.transport ?? 'none',
+                channelName: config?.channelName ?? '',
+                endpoint: config?.endpoint ?? false,
+                skipInTest: config?.skipInTest !== false,
+                hasOnStatsCallback: typeof config?.onStats === 'function',
+                hasShouldShowCallback: typeof config?.shouldShow === 'function',
+            },
+            devToolbar: {
+                enabled: !!toolbarConfig?.enabled,
+                maxQueries: toolbarConfig?.maxQueries ?? 500,
+                maxEvents: toolbarConfig?.maxEvents ?? 200,
+                maxEmails: toolbarConfig?.maxEmails ?? 100,
+                maxTraces: toolbarConfig?.maxTraces ?? 200,
+                slowQueryThresholdMs: toolbarConfig?.slowQueryThresholdMs ?? 100,
+                tracing: toolbarConfig?.tracing ?? false,
+                dashboard: toolbarConfig?.dashboard ?? false,
+                dashboardPath: toolbarConfig?.dashboardPath ?? '/__stats',
+                debugEndpoint: toolbarConfig?.debugEndpoint ?? '/admin/api/debug',
+                retentionDays: toolbarConfig?.retentionDays ?? 7,
+                dbPath: toolbarConfig?.dbPath ?? '.adonisjs/server-stats/dashboard.sqlite3',
+                persistDebugData: toolbarConfig?.persistDebugData ?? false,
+                renderer: toolbarConfig?.renderer ?? 'preact',
+                excludeFromTracing: toolbarConfig?.excludeFromTracing ?? [],
+                customPaneCount: toolbarConfig?.panes?.length ?? 0,
+            },
+        };
+    }
     async shutdown() {
         if (this.intervalId) {
             clearInterval(this.intervalId);
@@ -356,8 +646,8 @@ export default class ServerStatsProvider {
             try {
                 await this.debugStore.saveToDisk(this.persistPath);
             }
-            catch {
-                // Silently ignore save errors during shutdown
+            catch (err) {
+                log.warn('could not save debug data on shutdown — ' + err?.message);
             }
         }
         // Clean up dashboard resources

package/dist/src/routes/access_middleware.d.ts

@@ -1,8 +1,9 @@
+import type { HttpContext } from '@adonisjs/core/http';
 /**
  * Create a middleware function that gates access using the shouldShow callback.
  * Returns 403 if the callback returns false.
  *
  * Shared by stats, debug, and dashboard route registrars.
  */
-export declare function createAccessMiddleware(shouldShow: (ctx: any) => boolean): (ctx: any, next: () => Promise<void>) => Promise<any>;
+export declare function createAccessMiddleware(shouldShow: (ctx: HttpContext) => boolean): (ctx: HttpContext, next: () => Promise<void>) => Promise<void>;
 //# sourceMappingURL=access_middleware.d.ts.map

package/dist/src/routes/access_middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"access_middleware.d.ts","sourceRoot":"","sources":["../../../src/routes/access_middleware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,IACxD,KAAK,GAAG,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,kBAUlD"}
+{"version":3,"file":"access_middleware.d.ts","sourceRoot":"","sources":["../../../src/routes/access_middleware.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAItD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,IAChE,KAAK,WAAW,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,mBAgB1D"}

package/dist/src/routes/access_middleware.js

@@ -1,3 +1,5 @@
+import { log } from '../utils/logger.js';
+let warnedShouldShow = false;
 /**
  * Create a middleware function that gates access using the shouldShow callback.
  * Returns 403 if the callback returns false.
@@ -11,7 +13,11 @@ export function createAccessMiddleware(shouldShow) {
                 return ctx.response.forbidden({ error: 'Access denied' });
             }
         }
-        catch {
+        catch (err) {
+            if (!warnedShouldShow) {
+                warnedShouldShow = true;
+                log.warn('shouldShow callback threw in route guard — returning 403: ' + err?.message);
+            }
             return ctx.response.forbidden({ error: 'Access denied' });
         }
         await next();

package/dist/src/routes/index.d.ts

@@ -0,0 +1,4 @@
+export { registerAllRoutes } from './register_routes.js';
+export type { RegisterRoutesOptions } from './register_routes.js';
+export type { AdonisRoute, AdonisRouter } from './router_types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AACjE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/src/routes/index.js

@@ -0,0 +1 @@
+export { registerAllRoutes } from './register_routes.js';