@ngn-net/nestjs-telescope 0.1.12 → 0.2.0

package/README.md

@@ -1,5 +1,7 @@
 # @ngn-net/nestjs-telescope
 
+![NestJS Telescope Banner](assets/hero.png)
+
 A full-featured developer assistant and application monitoring suite for NestJS, inspired by Laravel Telescope. It monitors incoming HTTP requests, database queries, cache operations, background queue jobs, application events, outgoing mail, logs, unhandled exceptions, cron job schedules, and Redis commands.
 
 All telemetry records are persisted to a database table and accessible via a modern, high-fidelity dark-themed single-page application dashboard.
@@ -93,6 +95,33 @@ import { TelescopeModule, EntryType } from '@ngn-net/nestjs-telescope';
 export class AppModule {}
 ```
 
+### Async Configuration
+
+You can also register `TelescopeModule` asynchronously using a factory (e.g. inject `ConfigService`):
+
+```typescript
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { TelescopeModule } from '@ngn-net/nestjs-telescope';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    TelescopeModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (configService: ConfigService) => ({
+        path: configService.get('TELESCOPE_PATH', 'telescope'),
+        password: configService.get('TELESCOPE_PASSWORD', 'password'),
+        jwtSecret: configService.get('TELESCOPE_JWT_SECRET', 'my-secret'),
+        maxEntries: 1000,
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
 ---
 
 ## Dashboard Access

package/dist/dashboard.provider.d.ts

@@ -0,0 +1,5 @@
+import { NestMiddleware } from '@nestjs/common';
+import { Request, Response, NextFunction } from 'express';
+export declare class DashboardStaticMiddleware implements NestMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void;
+}

package/dist/dashboard.provider.js

@@ -0,0 +1,23 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardStaticMiddleware = void 0;
+const common_1 = require("@nestjs/common");
+let DashboardStaticMiddleware = class DashboardStaticMiddleware {
+    use(req, res, next) {
+        // Let Nest's ServeStatic handle static files; fallback to index.html for SPA routing
+        if (req.baseUrl && req.path.startsWith(req.baseUrl)) {
+            return next();
+        }
+        next();
+    }
+};
+exports.DashboardStaticMiddleware = DashboardStaticMiddleware;
+exports.DashboardStaticMiddleware = DashboardStaticMiddleware = __decorate([
+    (0, common_1.Injectable)()
+], DashboardStaticMiddleware);

package/dist/enums/entry-type.enum.d.ts

@@ -1,5 +1,6 @@
 export declare enum EntryType {
     REQUEST = "request",
+    HTTP_CLIENT = "http_client",
     QUERY = "query",
     CACHE = "cache",
     JOB = "job",

package/dist/enums/entry-type.enum.js

@@ -5,6 +5,7 @@ exports.EntryType = void 0;
 var EntryType;
 (function (EntryType) {
     EntryType["REQUEST"] = "request";
+    EntryType["HTTP_CLIENT"] = "http_client";
     EntryType["QUERY"] = "query";
     EntryType["CACHE"] = "cache";
     EntryType["JOB"] = "job";

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export * from './interfaces/telescope-options.interface';
 export * from './interfaces/entry.interface';
 export * from './guards/telescope-jwt.guard';
 export * from './constants';
+export * from './dashboard.provider';
 export * from './watchers/http-request.watcher';
 export * from './watchers/query.watcher';
 export * from './watchers/cache.watcher';

package/dist/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./interfaces/telescope-options.interface"), exports);
 __exportStar(require("./interfaces/entry.interface"), exports);
 __exportStar(require("./guards/telescope-jwt.guard"), exports);
 __exportStar(require("./constants"), exports);
+__exportStar(require("./dashboard.provider"), exports);
 // Export all watchers for custom usage/extension
 __exportStar(require("./watchers/http-request.watcher"), exports);
 __exportStar(require("./watchers/query.watcher"), exports);

package/dist/interfaces/telescope-options.interface.d.ts

@@ -4,6 +4,8 @@ export interface TelescopeOptions {
     path?: string;
     /** JWT secret used for UI authentication */
     jwtSecret?: string;
+    /** Enable the dashboard UI (default: true) */
+    enableDashboard?: boolean;
     /** Password for dashboard login (default: 'password', or env TELESCOPE_PASSWORD) */
     password?: string;
     /** Which entry types to enable (default: all) */
@@ -17,3 +19,13 @@ export interface TelescopeOptions {
     /** Additional middleware to apply to UI routes */
     uiMiddleware?: any[];
 }
+export interface TelescopeOptionsFactory {
+    createTelescopeOptions(): Promise<TelescopeOptions> | TelescopeOptions;
+}
+export interface TelescopeModuleAsyncOptions {
+    imports?: any[];
+    useExisting?: any;
+    useClass?: any;
+    useFactory?: (...args: any[]) => Promise<TelescopeOptions> | TelescopeOptions;
+    inject?: any[];
+}

package/dist/telescope.module.d.ts

@@ -1,10 +1,14 @@
 import { DynamicModule, OnModuleInit } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
+import { TelescopeOptions, TelescopeModuleAsyncOptions } from './interfaces/telescope-options.interface';
 export declare class TelescopeModule implements OnModuleInit {
     private readonly moduleRef;
-    constructor(moduleRef: ModuleRef);
+    private readonly options;
+    constructor(moduleRef: ModuleRef, options: TelescopeOptions);
     onModuleInit(): void;
-    static forRoot(options?: any): DynamicModule;
-    private static registerWatchers;
-    static forRootAsync(optionsFactory: any): DynamicModule;
+    static forRoot(options?: TelescopeOptions): DynamicModule;
+    static forRootAsync(options: TelescopeModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static registerWatchersAndModules;
+    private static registerWatchersAndModulesAsync;
 }

package/dist/telescope.module.js

@@ -8,10 +8,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var TelescopeModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelescopeModule = void 0;
-// src/telescope.module.ts
 const common_1 = require("@nestjs/common");
 const serve_static_1 = require("@nestjs/serve-static");
 const path_1 = require("path");
@@ -37,10 +39,38 @@ const constants_1 = require("./constants");
 const entry_type_enum_1 = require("./enums/entry-type.enum");
 let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
     moduleRef;
-    constructor(moduleRef) {
+    options;
+    constructor(moduleRef, options) {
         this.moduleRef = moduleRef;
+        this.options = options;
+        const path = this.options.path || constants_1.DEFAULT_TELESCOPE_PATH;
+        Reflect.defineMetadata('path', path, telescope_controller_1.TelescopeController);
     }
     onModuleInit() {
+        // Dynamic peer dependency validation at bootstrap
+        const hasDependency = (type, packageName) => {
+            try {
+                require(packageName);
+                return true;
+            }
+            catch (e) {
+                if (this.options.enabledEntryTypes && this.options.enabledEntryTypes.includes(type)) {
+                    throw new Error(`NestJS Telescope Error: EntryType '${type}' was explicitly enabled in config, but the required peer dependency '${packageName}' is not installed.`);
+                }
+                return false;
+            }
+        };
+        hasDependency(entry_type_enum_1.EntryType.CACHE, '@nestjs/cache-manager');
+        const hasBull = hasDependency(entry_type_enum_1.EntryType.JOB, '@nestjs/bullmq');
+        const hasBullmq = hasDependency(entry_type_enum_1.EntryType.JOB, 'bullmq');
+        if (this.options.enabledEntryTypes && this.options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.JOB)) {
+            if (!hasBull || !hasBullmq) {
+                throw new Error(`NestJS Telescope Error: EntryType 'JOB' was explicitly enabled in config, but the required peer dependencies '@nestjs/bullmq' and 'bullmq' are not installed.`);
+            }
+        }
+        hasDependency(entry_type_enum_1.EntryType.EVENT, '@nestjs/event-emitter');
+        hasDependency(entry_type_enum_1.EntryType.SCHEDULED_TASK, '@nestjs/schedule');
+        hasDependency(entry_type_enum_1.EntryType.MAIL, 'nodemailer');
         // Dynamic EventEmitter2 configuration
         try {
             const eventWatcher = this.moduleRef.get(event_watcher_1.EventWatcher, { strict: false });
@@ -81,7 +111,7 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
         // Serve static UI assets if dashboard is enabled (default true)
         if (options.enableDashboard !== false) {
             const staticPath = (0, path_1.join)(__dirname, '..', 'ui');
-            const routePath = options.path || 'telescope';
+            const routePath = options.path || constants_1.DEFAULT_TELESCOPE_PATH;
             imports.push(serve_static_1.ServeStaticModule.forRoot({
                 rootPath: staticPath,
                 serveRoot: `/${routePath}`,
@@ -96,145 +126,209 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
             telescope_repository_service_1.TelescopeRepository,
             telescope_jwt_guard_1.JwtAuthGuard,
         ];
-        // Always registered watchers (no external peer dependencies needed)
-        const watchersToRegister = [
+        // Register watchers (both core and optional)
+        this.registerWatchersAndModules(options, providers, imports);
+        return {
+            module: TelescopeModule_1,
+            imports,
+            providers,
+            controllers: [telescope_controller_1.TelescopeController],
+            exports: [telescope_service_1.TelescopeService, telescope_repository_service_1.TelescopeRepository],
+        };
+    }
+    static forRootAsync(options) {
+        const providers = [
+            ...this.createAsyncProviders(options),
+            telescope_service_1.TelescopeService,
+            telescope_repository_service_1.TelescopeRepository,
+            telescope_jwt_guard_1.JwtAuthGuard,
+        ];
+        const imports = [
+            typeorm_1.TypeOrmModule.forFeature([telescope_entry_entity_1.TelescopeEntry]),
+            jwt_1.JwtModule.registerAsync({
+                imports: options.imports || [],
+                inject: [constants_1.TELESCOPE_OPTIONS],
+                useFactory: async (telescopeOpts) => ({
+                    secret: telescopeOpts.jwtSecret || process.env.TELESCOPE_JWT_SECRET || constants_1.DEFAULT_JWT_SECRET,
+                    signOptions: { expiresIn: '1d' },
+                }),
+            }),
+        ];
+        // Serve static UI assets if dashboard is enabled (default true)
+        imports.push(serve_static_1.ServeStaticModule.forRootAsync({
+            imports: options.imports || [],
+            inject: [constants_1.TELESCOPE_OPTIONS],
+            useFactory: (telescopeOpts) => {
+                if (telescopeOpts.enableDashboard === false) {
+                    return [];
+                }
+                const staticPath = (0, path_1.join)(__dirname, '..', 'ui');
+                const routePath = telescopeOpts.path || constants_1.DEFAULT_TELESCOPE_PATH;
+                return [
+                    {
+                        rootPath: staticPath,
+                        serveRoot: `/${routePath}`,
+                    },
+                ];
+            },
+        }));
+        // Register all available/supported watchers & modules dynamically
+        this.registerWatchersAndModulesAsync(providers, imports);
+        return {
+            module: TelescopeModule_1,
+            imports,
+            providers,
+            controllers: [telescope_controller_1.TelescopeController],
+            exports: [telescope_service_1.TelescopeService, telescope_repository_service_1.TelescopeRepository],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: constants_1.TELESCOPE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
+        }
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return [
+                {
+                    provide: constants_1.TELESCOPE_OPTIONS,
+                    useFactory: async (optionsFactory) => await optionsFactory.createTelescopeOptions(),
+                    inject: [useClass],
+                },
+                {
+                    provide: useClass,
+                    useClass: options.useClass,
+                },
+            ];
+        }
+        return [];
+    }
+    static registerWatchersAndModules(options, providers, imports) {
+        // 1. Core watchers (always registered if enabled or not specified)
+        const coreWatchers = [
             { type: entry_type_enum_1.EntryType.REQUEST, watcher: http_request_watcher_1.HttpRequestWatcher, isInterceptor: true },
             { type: entry_type_enum_1.EntryType.QUERY, watcher: query_watcher_1.QueryWatcher },
             { type: entry_type_enum_1.EntryType.LOG, watcher: log_watcher_1.LogWatcher },
             { type: entry_type_enum_1.EntryType.EXCEPTION, watcher: exception_watcher_1.ExceptionWatcher, isInterceptor: true },
             { type: entry_type_enum_1.EntryType.REDIS, watcher: redis_watcher_1.RedisWatcher },
         ];
-        // Register core watchers
-        this.registerWatchers(options, providers);
-        // Optional dependencies checking:
-        // 1. CacheWatcher (@nestjs/cache-manager)
-        let hasCache = false;
+        for (const item of coreWatchers) {
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(item.type)) {
+                if (item.isInterceptor) {
+                    providers.push({ provide: core_1.APP_INTERCEPTOR, useClass: item.watcher });
+                }
+                else {
+                    providers.push(item.watcher);
+                }
+            }
+        }
+        // 2. CacheWatcher
         try {
             require('@nestjs/cache-manager');
-            hasCache = true;
-        }
-        catch { }
-        if (hasCache && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.CACHE))) {
-            try {
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.CACHE)) {
                 const { CacheModule } = require('@nestjs/cache-manager');
-                if (CacheModule) {
-                    imports.push(CacheModule.register({}));
-                    providers.push(cache_watcher_1.CacheWatcher);
-                }
+                imports.push(CacheModule.register({}));
+                providers.push(cache_watcher_1.CacheWatcher);
             }
-            catch { }
         }
-        // 2. QueueWatcher (@nestjs/bullmq & bullmq)
-        let hasBull = false;
+        catch (e) { }
+        // 3. QueueWatcher
         try {
             require('@nestjs/bullmq');
             require('bullmq');
-            hasBull = true;
-        }
-        catch { }
-        if (hasBull && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.JOB))) {
-            try {
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.JOB)) {
                 const { BullModule } = require('@nestjs/bullmq');
-                if (BullModule) {
-                    imports.push(BullModule.registerQueue({
-                        name: 'telescope-queue',
-                        connection: {
-                            host: process.env.REDIS_HOST || '127.0.0.1',
-                            port: Number(process.env.REDIS_PORT) || 6379,
-                        },
-                    }));
-                    providers.push(queue_watcher_1.QueueWatcher);
-                }
+                imports.push(BullModule.registerQueue({
+                    name: 'telescope-queue',
+                    connection: {
+                        host: process.env.REDIS_HOST || '127.0.0.1',
+                        port: Number(process.env.REDIS_PORT) || 6379,
+                    },
+                }));
+                providers.push(queue_watcher_1.QueueWatcher);
             }
-            catch { }
         }
-        // 3. EventWatcher (@nestjs/event-emitter)
-        let hasEvents = false;
+        catch (e) { }
+        // 4. EventWatcher
         try {
             require('@nestjs/event-emitter');
-            hasEvents = true;
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.EVENT)) {
+                providers.push(event_watcher_1.EventWatcher);
+            }
+        }
+        catch (e) { }
+        // 5. ScheduleWatcher
+        try {
+            require('@nestjs/schedule');
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.SCHEDULED_TASK)) {
+                providers.push(schedule_watcher_1.ScheduleWatcher);
+            }
+        }
+        catch (e) { }
+        // 6. MailWatcher
+        try {
+            require('nodemailer');
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.MAIL)) {
+                providers.push(mail_watcher_1.MailWatcher);
+            }
+        }
+        catch (e) { }
+    }
+    static registerWatchersAndModulesAsync(providers, imports) {
+        // Core interceptors and watchers
+        providers.push({ provide: core_1.APP_INTERCEPTOR, useClass: http_request_watcher_1.HttpRequestWatcher });
+        providers.push({ provide: core_1.APP_INTERCEPTOR, useClass: exception_watcher_1.ExceptionWatcher });
+        providers.push(query_watcher_1.QueryWatcher);
+        providers.push(log_watcher_1.LogWatcher);
+        providers.push(redis_watcher_1.RedisWatcher);
+        // Optional modules/watchers if packages are present
+        try {
+            require('@nestjs/cache-manager');
+            const { CacheModule } = require('@nestjs/cache-manager');
+            imports.push(CacheModule.register({}));
+            providers.push(cache_watcher_1.CacheWatcher);
         }
-        catch { }
-        if (hasEvents && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.EVENT))) {
+        catch (e) { }
+        try {
+            require('@nestjs/bullmq');
+            require('bullmq');
+            const { BullModule } = require('@nestjs/bullmq');
+            imports.push(BullModule.registerQueue({
+                name: 'telescope-queue',
+                connection: {
+                    host: process.env.REDIS_HOST || '127.0.0.1',
+                    port: Number(process.env.REDIS_PORT) || 6379,
+                },
+            }));
+            providers.push(queue_watcher_1.QueueWatcher);
+        }
+        catch (e) { }
+        try {
+            require('@nestjs/event-emitter');
             providers.push(event_watcher_1.EventWatcher);
         }
-        // 4. ScheduleWatcher (@nestjs/schedule)
-        let hasSchedule = false;
+        catch (e) { }
         try {
             require('@nestjs/schedule');
-            hasSchedule = true;
-        }
-        catch { }
-        if (hasSchedule && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.SCHEDULED_TASK))) {
             providers.push(schedule_watcher_1.ScheduleWatcher);
         }
-        // 5. MailWatcher (nodemailer)
-        let hasNodemailer = false;
+        catch (e) { }
         try {
             require('nodemailer');
-            hasNodemailer = true;
-        }
-        catch { }
-        if (hasNodemailer && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.MAIL))) {
             providers.push(mail_watcher_1.MailWatcher);
         }
-        // Dynamic Route Prefix Setup using Reflect metadata on TelescopeController
-        const path = options.path || 'telescope';
-        Reflect.defineMetadata('path', path, telescope_controller_1.TelescopeController);
-        // Ensure static assets are served under the same path when dashboard enabled
-        if (options.enableDashboard !== false) {
-            // ServeStaticModule already handles static files; no extra code needed here.
-        }
-        return {
-            module: TelescopeModule_1,
-            imports,
-            providers,
-            controllers: [telescope_controller_1.TelescopeController],
-            exports: [telescope_service_1.TelescopeService, telescope_repository_service_1.TelescopeRepository],
-        };
-    }
-    // Helper to register core watchers
-    static registerWatchers(options, providers) {
-        const watchersToRegister = [
-            { type: entry_type_enum_1.EntryType.REQUEST, watcher: http_request_watcher_1.HttpRequestWatcher, isInterceptor: true },
-            { type: entry_type_enum_1.EntryType.QUERY, watcher: query_watcher_1.QueryWatcher },
-            { type: entry_type_enum_1.EntryType.LOG, watcher: log_watcher_1.LogWatcher },
-            { type: entry_type_enum_1.EntryType.EXCEPTION, watcher: exception_watcher_1.ExceptionWatcher, isInterceptor: true },
-            { type: entry_type_enum_1.EntryType.REDIS, watcher: redis_watcher_1.RedisWatcher },
-        ];
-        for (const item of watchersToRegister) {
-            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(item.type)) {
-                if (item.isInterceptor) {
-                    providers.push({ provide: core_1.APP_INTERCEPTOR, useClass: item.watcher });
-                }
-                else {
-                    providers.push(item.watcher);
-                }
-            }
-        }
-    }
-    static forRootAsync(optionsFactory) {
-        // Allows async injection of TelescopeOptions (e.g., from ConfigService)
-        return {
-            module: TelescopeModule_1,
-            imports: [
-                typeorm_1.TypeOrmModule.forFeature([telescope_entry_entity_1.TelescopeEntry]),
-                jwt_1.JwtModule.registerAsync({
-                    useFactory: async (options) => ({
-                        secret: options.jwtSecret || process.env.TELESCOPE_JWT_SECRET || constants_1.DEFAULT_JWT_SECRET,
-                        signOptions: { expiresIn: '1d' },
-                    }),
-                    inject: [optionsFactory],
-                }),
-            ],
-            providers: [],
-            controllers: [telescope_controller_1.TelescopeController],
-        };
+        catch (e) { }
     }
 };
 exports.TelescopeModule = TelescopeModule;
 exports.TelescopeModule = TelescopeModule = TelescopeModule_1 = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({}),
-    __metadata("design:paramtypes", [core_1.ModuleRef])
+    __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
 ], TelescopeModule);

package/dist/telescope.service.d.ts

@@ -1,4 +1,5 @@
 import { OnModuleInit } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
 import { TelescopeRepository } from './storage/telescope-repository.service';
 import { TelescopeEntry } from './storage/entities/telescope-entry.entity';
 import { EntryType } from './enums/entry-type.enum';
@@ -6,10 +7,15 @@ import { TelescopeOptions } from './interfaces/telescope-options.interface';
 export declare class TelescopeService implements OnModuleInit {
     private readonly repo;
     private readonly options?;
+    private readonly adapterHost?;
     private lastPruneTime;
     private readonly asyncLocalStorage;
-    constructor(repo: TelescopeRepository, options?: TelescopeOptions | undefined);
+    constructor(repo: TelescopeRepository, options?: TelescopeOptions | undefined, adapterHost?: HttpAdapterHost | undefined);
     onModuleInit(): Promise<void>;
+    /**
+     * Get the full URL to the Telescope dashboard.
+     */
+    getDashboardUrl(): string;
     /**
      * Check if a specific entry type is enabled in the options.
      * If `enabledEntryTypes` is not configured, all types are enabled.

package/dist/telescope.service.js

@@ -16,20 +16,52 @@ exports.TelescopeService = void 0;
 // src/telescope.service.ts
 const common_1 = require("@nestjs/common");
 const async_hooks_1 = require("async_hooks");
+const core_1 = require("@nestjs/core");
 const telescope_repository_service_1 = require("./storage/telescope-repository.service");
 const constants_1 = require("./constants");
 let TelescopeService = class TelescopeService {
     repo;
     options;
+    adapterHost;
     lastPruneTime = 0;
     asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
-    constructor(repo, options) {
+    constructor(repo, options, adapterHost) {
         this.repo = repo;
         this.options = options;
+        this.adapterHost = adapterHost;
     }
     async onModuleInit() {
         // Module is initialized; TypeORM will handle schema sync
     }
+    /**
+     * Get the full URL to the Telescope dashboard.
+     */
+    getDashboardUrl() {
+        const path = this.options?.path || 'telescope';
+        if (!this.adapterHost) {
+            return `/${path}`;
+        }
+        try {
+            const httpAdapter = this.adapterHost.httpAdapter;
+            if (!httpAdapter) {
+                return `/${path}`;
+            }
+            const instance = httpAdapter.getInstance();
+            if (instance && typeof instance.address === 'function') {
+                const address = instance.address();
+                if (address) {
+                    const host = typeof address === 'string' ? address : address.address === '::' ? 'localhost' : address.address;
+                    const port = typeof address === 'string' ? '' : `:${address.port}`;
+                    const protocol = 'http';
+                    return `${protocol}://${host}${port}/${path}`;
+                }
+            }
+        }
+        catch (e) {
+            // Fallback
+        }
+        return `/${path}`;
+    }
     /**
      * Check if a specific entry type is enabled in the options.
      * If `enabledEntryTypes` is not configured, all types are enabled.
@@ -110,5 +142,6 @@ exports.TelescopeService = TelescopeService = __decorate([
     (0, common_1.Injectable)(),
     __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
     __param(1, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository, Object])
+    __param(2, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository, Object, core_1.HttpAdapterHost])
 ], TelescopeService);

package/dist/ui/manifest.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ngn-net/nestjs-telescope",
+  "version": "0.2.0",
+  "builtAt": "2026-06-08T11:00:55.375Z"
+}

package/dist/watchers/http-client.watcher.d.ts

@@ -0,0 +1,11 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+import { TelescopeOptions } from '../interfaces/telescope-options.interface';
+export declare class HttpClientWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly options?;
+    private patched;
+    constructor(telescope: TelescopeService, options?: TelescopeOptions | undefined);
+    onModuleInit(): void;
+    private patch;
+}

package/dist/watchers/http-client.watcher.js

@@ -0,0 +1,200 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientWatcher = void 0;
+// src/watchers/http-client.watcher.ts
+const common_1 = require("@nestjs/common");
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+const constants_1 = require("../constants");
+let HttpClientWatcher = class HttpClientWatcher {
+    telescope;
+    options;
+    patched = false;
+    constructor(telescope, options) {
+        this.telescope = telescope;
+        this.options = options;
+    }
+    onModuleInit() {
+        if (this.patched)
+            return;
+        this.patched = true;
+        this.patch(http);
+        this.patch(https);
+    }
+    patch(module) {
+        const originalRequest = module.request.bind(module);
+        const self = this;
+        // Override module.request
+        module.request = function (...args) {
+            const req = originalRequest(...args);
+            const startTime = Date.now();
+            // Resolve URL and method
+            let urlStr = '';
+            let method = 'GET';
+            try {
+                const firstArg = args[0];
+                if (typeof firstArg === 'string') {
+                    urlStr = firstArg;
+                }
+                else if (firstArg instanceof URL) {
+                    urlStr = firstArg.toString();
+                }
+                else if (typeof firstArg === 'object' && firstArg !== null) {
+                    const { protocol, hostname, host, port, path: urlPath } = firstArg;
+                    const proto = protocol || 'http:';
+                    const h = hostname || host || 'localhost';
+                    const p = port ? `:${port}` : '';
+                    urlStr = `${proto}//${h}${p}${urlPath || '/'}`;
+                    method = (firstArg.method || 'GET').toUpperCase();
+                }
+            }
+            catch {
+                urlStr = '';
+            }
+            // Ignore telescope's own internal paths and configured ignore list
+            if (self.telescope.shouldIgnorePath(urlStr)) {
+                return req;
+            }
+            // Skip if this type is disabled
+            if (!self.telescope.isEnabled(entry_type_enum_1.EntryType.HTTP_CLIENT)) {
+                return req;
+            }
+            // Capture request body chunks written
+            const reqChunks = [];
+            const originalWrite = req.write.bind(req);
+            const originalEnd = req.end.bind(req);
+            req.write = function (chunk, ...rest) {
+                if (chunk)
+                    reqChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                return originalWrite(chunk, ...rest);
+            };
+            req.end = function (chunk, ...rest) {
+                if (chunk)
+                    reqChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                return originalEnd(chunk, ...rest);
+            };
+            // Capture request headers snapshot after end
+            req.on('finish', () => {
+                // headers captured at response time
+            });
+            req.on('response', (res) => {
+                const resChunks = [];
+                res.on('data', (chunk) => {
+                    resChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                });
+                res.on('end', () => {
+                    const duration = Date.now() - startTime;
+                    const requestBodyRaw = Buffer.concat(reqChunks).toString('utf8');
+                    const responseBodyRaw = Buffer.concat(resChunks).toString('utf8');
+                    let requestBody = requestBodyRaw;
+                    let responseBody = responseBodyRaw;
+                    try {
+                        requestBody = JSON.parse(requestBodyRaw);
+                    }
+                    catch { /* keep raw */ }
+                    try {
+                        responseBody = JSON.parse(responseBodyRaw);
+                    }
+                    catch { /* keep raw */ }
+                    // Sanitize headers — remove Authorization tokens from logs
+                    const reqHeaders = { ...req.getHeaders?.() };
+                    if (reqHeaders['authorization']) {
+                        reqHeaders['authorization'] = '[REDACTED]';
+                    }
+                    self.telescope.record({
+                        type: entry_type_enum_1.EntryType.HTTP_CLIENT,
+                        content: {
+                            method: method || (req.method || 'GET').toUpperCase(),
+                            url: urlStr,
+                            requestHeaders: reqHeaders,
+                            requestBody,
+                            responseStatus: res.statusCode,
+                            responseHeaders: res.headers,
+                            responseBody,
+                            duration,
+                        },
+                    }).catch(() => { });
+                });
+                res.on('error', () => { });
+            });
+            req.on('error', (err) => {
+                const duration = Date.now() - startTime;
+                self.telescope.record({
+                    type: entry_type_enum_1.EntryType.HTTP_CLIENT,
+                    content: {
+                        method,
+                        url: urlStr,
+                        requestHeaders: {},
+                        requestBody: null,
+                        responseStatus: 0,
+                        responseBody: null,
+                        error: err.message,
+                        duration,
+                    },
+                }).catch(() => { });
+            });
+            return req;
+        };
+        // Also handle module.get (convenience method)
+        const originalGet = module.get.bind(module);
+        module.get = function (...args) {
+            const req = module.request(...args);
+            req.end();
+            return req;
+        };
+    }
+};
+exports.HttpClientWatcher = HttpClientWatcher;
+exports.HttpClientWatcher = HttpClientWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService, Object])
+], HttpClientWatcher);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.1.12",
+  "version": "0.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -73,16 +73,21 @@
     "@nestjs/event-emitter": "^2",
     "@nestjs/jwt": "^11",
     "@nestjs/passport": "^11",
+    "@nestjs/platform-express": "^11.1.25",
     "@nestjs/schedule": "^4",
+    "@nestjs/testing": "^11.1.25",
     "@nestjs/typeorm": "^11",
     "@types/express": "^4.17.21",
     "@types/jest": "^29",
     "@types/node": "^20",
     "@types/nodemailer": "^6.4.15",
+    "@types/supertest": "^7.2.0",
     "jest": "^29",
     "nodemailer": "^6",
     "rimraf": "^5",
     "rxjs": "^7",
+    "sqlite3": "^6.0.1",
+    "supertest": "^7.2.2",
     "ts-jest": "^29",
     "ts-node": "^10",
     "typeorm": "^0.3",