@vipin733/nodescope 0.1.0 → 0.2.0

package/README.md

@@ -9,7 +9,7 @@
 
 - 📊 **Real-time Monitoring** - Watch requests, queries, and logs as they happen via WebSocket streaming
 - 💾 **Multiple Storage Backends** - Choose from in-memory, SQLite, PostgreSQL, or MySQL
-- 🔌 **Framework Agnostic** - First-class support for Express, Hono, Fastify, and vanilla Node.js
+- 🔌 **Framework Agnostic** - First-class support for Express, Hono, Fastify, NestJS, and vanilla Node.js
 - 🎨 **Beautiful Dashboard** - React-based UI with dark/light mode (coming soon)
 - 🚀 **Zero Configuration** - Sensible defaults, just install and go
 - 🔍 **Comprehensive Watchers** - Track requests, database queries, logs, exceptions, and more
@@ -119,6 +119,96 @@ fastify.get('/', async (request, reply) => {
 await fastify.listen({ port: 3000 });
 ```
 
+### NestJS
+
+```typescript
+import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { 
+  NodeScope,
+  NodeScopeModule, 
+  NodeScopeMiddleware,
+  setupNodeScopeRoutes 
+} from '@vipin733/nodescope';
+
+@Module({
+  imports: [
+    NodeScopeModule.forRoot({
+      storage: 'memory',
+      dashboardPath: '/_debug',
+    }),
+  ],
+})
+export class AppModule implements NestModule {
+  constructor(private readonly nodescope: NodeScope) {}
+
+  configure(consumer: MiddlewareConsumer) {
+    // Apply NodeScope middleware to all routes
+    const middleware = new NodeScopeMiddleware(this.nodescope);
+    consumer
+      .apply((req, res, next) => middleware.use(req, res, next))
+      .forRoutes('*');
+  }
+}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  
+  // Set up dashboard routes
+  const nodescope = app.get('NODESCOPE_INSTANCE');
+  await setupNodeScopeRoutes(app, nodescope);
+  
+  await app.listen(3000);
+}
+bootstrap();
+```
+
+#### NestJS with ConfigService (Async Configuration)
+
+```typescript
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { NodeScopeModule } from '@vipin733/nodescope';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    NodeScopeModule.forRootAsync({
+      useFactory: (configService: ConfigService) => ({
+        storage: configService.get('NODESCOPE_STORAGE') || 'sqlite',
+        dashboardPath: '/_debug',
+        enabled: configService.get('NODE_ENV') === 'development',
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+#### NestJS Global Interceptor (Alternative to Middleware)
+
+```typescript
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { NodeScopeModule, NodeScopeInterceptor } from '@vipin733/nodescope';
+
+@Module({
+  imports: [
+    NodeScopeModule.forRoot({
+      storage: 'memory',
+    }),
+  ],
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: NodeScopeInterceptor,
+    },
+  ],
+})
+export class AppModule {}
+```
+
 ## ⚙️ Configuration
 
 ### Constructor Options
@@ -367,6 +457,28 @@ import { createFastifyPlugin } from '@vipin733/nodescope';
 await fastify.register(createFastifyPlugin, options);
 ```
 
+#### NestJS
+
+```typescript
+import { NodeScopeModule, NodeScopeMiddleware, NodeScopeInterceptor } from '@vipin733/nodescope';
+
+// Module approach
+@Module({
+  imports: [NodeScopeModule.forRoot(options)],
+})
+
+// Or async configuration
+NodeScopeModule.forRootAsync({
+  useFactory: (config: ConfigService) => ({...}),
+  inject: [ConfigService],
+})
+
+// Use middleware or interceptor
+consumer.apply(NodeScopeMiddleware).forRoutes('*');
+// or
+{ provide: APP_INTERCEPTOR, useClass: NodeScopeInterceptor }
+```
+
 ## 🛠️ Development
 
 ```bash
@@ -394,6 +506,7 @@ Check out the [examples](https://github.com/yourusername/nodescope/tree/main/exa
 - Express.js example
 - Hono example
 - Fastify example
+- NestJS example
 
 ## 🤝 Contributing
 

package/dist/index.cjs

@@ -806,6 +806,10 @@ __export(index_exports, {
   MemoryStorage: () => MemoryStorage,
   MySQLStorage: () => MySQLStorage,
   NodeScope: () => NodeScope,
+  NodeScopeController: () => NodeScopeController,
+  NodeScopeInterceptor: () => NodeScopeInterceptor,
+  NodeScopeMiddleware: () => NodeScopeMiddleware,
+  NodeScopeModule: () => NodeScopeModule,
   PostgreSQLStorage: () => PostgreSQLStorage,
   QueryWatcher: () => QueryWatcher,
   RealTimeServer: () => RealTimeServer,
@@ -831,6 +835,7 @@ __export(index_exports, {
   mountExpressRoutes: () => mountExpressRoutes,
   nodescope: () => nodescope,
   setupGlobalErrorHandlers: () => setupGlobalErrorHandlers,
+  setupNodeScopeRoutes: () => setupNodeScopeRoutes,
   wrapFetch: () => wrapFetch,
   wrapJobProcessor: () => wrapJobProcessor,
   wrapPrisma: () => wrapPrisma
@@ -2882,6 +2887,317 @@ async function fastifyNodeScope(fastify, options) {
     return reply.status(response.status).send(response.body);
   });
 }
+
+// src/adapters/nestjs.ts
+var NodeScopeMiddleware = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async use(req, res, next) {
+    const nodescope2 = this.nodescope;
+    if (!nodescope2 || !nodescope2.isEnabled) {
+      return next();
+    }
+    const dashboardPath = nodescope2.dashboardPath;
+    if (req.path?.startsWith(dashboardPath)) {
+      return next();
+    }
+    const ctx = nodescope2.createContext();
+    req.nodescope = ctx;
+    const originalSend = res.send;
+    const originalJson = res.json;
+    let responseBody;
+    res.send = function(body) {
+      responseBody = body;
+      return originalSend.call(this, body);
+    };
+    res.json = function(body) {
+      responseBody = body;
+      return originalJson.call(this, body);
+    };
+    res.on("finish", async () => {
+      if (!nodescope2.requestWatcher.enabled) return;
+      try {
+        const entry = nodescope2.requestWatcher.record({
+          batchId: ctx.batchId,
+          startTime: ctx.startTime,
+          method: req.method,
+          url: req.originalUrl || req.url,
+          path: req.path || req.route?.path,
+          query: req.query,
+          headers: req.headers,
+          body: req.body,
+          ip: req.ip || req.socket?.remoteAddress,
+          userAgent: req.get?.("user-agent"),
+          session: req.session,
+          response: {
+            status: res.statusCode,
+            headers: res.getHeaders?.() || {},
+            body: responseBody
+          }
+        });
+        if (entry) {
+          await nodescope2.recordEntry(entry);
+        }
+      } catch (error) {
+      }
+    });
+    next();
+  }
+};
+var NodeScopeInterceptor = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async intercept(context, next) {
+    if (!this.nodescope.isEnabled) {
+      return next.handle();
+    }
+    const http = context.switchToHttp();
+    const request = http.getRequest();
+    const response = http.getResponse();
+    const dashboardPath = this.nodescope.dashboardPath;
+    if (request.path?.startsWith(dashboardPath)) {
+      return next.handle();
+    }
+    const ctx = this.nodescope.createContext();
+    request.nodescope = ctx;
+    const { tap } = await import("rxjs/operators");
+    return next.handle().pipe(
+      tap({
+        next: async (data) => {
+          if (!this.nodescope.requestWatcher.enabled) return;
+          try {
+            const entry = this.nodescope.requestWatcher.record({
+              batchId: ctx.batchId,
+              startTime: ctx.startTime,
+              method: request.method,
+              url: request.originalUrl || request.url,
+              path: request.path || request.route?.path,
+              query: request.query,
+              headers: request.headers,
+              body: request.body,
+              ip: request.ip || request.socket?.remoteAddress,
+              userAgent: request.get?.("user-agent"),
+              session: request.session,
+              response: {
+                status: response.statusCode,
+                headers: response.getHeaders?.() || {},
+                body: data
+              }
+            });
+            if (entry) {
+              await this.nodescope.recordEntry(entry);
+            }
+          } catch (error) {
+            console.error("NodeScope error recording request:", error);
+          }
+        },
+        error: async (error) => {
+          if (!this.nodescope.exceptionWatcher.enabled) return;
+          try {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const entry = this.nodescope.exceptionWatcher.record({
+              error: errorObj,
+              context: {
+                method: request.method,
+                url: request.url,
+                statusCode: error.status || 500
+              }
+            });
+            if (entry) {
+              await this.nodescope.recordEntry(entry);
+            }
+          } catch (recordError) {
+            console.error("NodeScope error recording exception:", recordError);
+          }
+        }
+      })
+    );
+  }
+};
+var NodeScopeController = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async getDashboard(req, res) {
+    const authorized = await this.nodescope.checkAuthorization(req);
+    if (!authorized) {
+      res.status(403).json({ error: "Unauthorized" });
+      return;
+    }
+    res.setHeader("Content-Type", "text/html");
+    res.send(getDashboardHtml(this.nodescope.dashboardPath));
+  }
+  async handleApi(req, res) {
+    const authorized = await this.nodescope.checkAuthorization(req);
+    if (!authorized) {
+      res.status(403).json({ error: "Unauthorized" });
+      return;
+    }
+    const apiPath = req.path.replace(this.nodescope.dashboardPath, "");
+    const response = await this.nodescope.api.handle({
+      method: req.method,
+      url: apiPath,
+      query: req.query,
+      body: req.body
+    });
+    if (response.headers) {
+      for (const [key, value] of Object.entries(response.headers)) {
+        res.setHeader(key, value);
+      }
+    }
+    res.status(response.status).json(response.body);
+  }
+};
+var NodeScopeModule = class _NodeScopeModule {
+  /**
+   * Create a dynamic NestJS module for NodeScope
+   * 
+   * @example
+   * ```typescript
+   * import { Module } from '@nestjs/common';
+   * import { NodeScopeModule } from '@vipin733/nodescope';
+   * 
+   * @Module({
+   *   imports: [
+   *     NodeScopeModule.forRoot({
+   *       storage: 'sqlite',
+   *       dashboardPath: '/_debug',
+   *     }),
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRoot(config = {}) {
+    const nodescope2 = new NodeScope(config);
+    nodescope2.initialize().catch((err) => {
+      console.error("Failed to initialize NodeScope:", err);
+    });
+    return {
+      module: _NodeScopeModule,
+      providers: [
+        {
+          provide: "NODESCOPE_INSTANCE",
+          useValue: nodescope2
+        },
+        {
+          provide: NodeScope,
+          useValue: nodescope2
+        },
+        {
+          provide: NodeScopeMiddleware,
+          useFactory: () => new NodeScopeMiddleware(nodescope2)
+        },
+        {
+          provide: NodeScopeInterceptor,
+          useFactory: () => new NodeScopeInterceptor(nodescope2)
+        },
+        {
+          provide: NodeScopeController,
+          useFactory: () => new NodeScopeController(nodescope2)
+        }
+      ],
+      exports: ["NODESCOPE_INSTANCE", NodeScope, NodeScopeMiddleware, NodeScopeInterceptor],
+      global: true
+    };
+  }
+  /**
+   * Create an async dynamic module
+   * Useful when you need to inject other services
+   * 
+   * @example
+   * ```typescript
+   * NodeScopeModule.forRootAsync({
+   *   useFactory: (configService: ConfigService) => ({
+   *     storage: configService.get('NODESCOPE_STORAGE'),
+   *     dashboardPath: '/_debug',
+   *     enabled: configService.get('NODE_ENV') === 'development',
+   *   }),
+   *   inject: [ConfigService],
+   * })
+   * ```
+   */
+  static forRootAsync(options) {
+    return {
+      module: _NodeScopeModule,
+      providers: [
+        {
+          provide: "NODESCOPE_CONFIG",
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
+        {
+          provide: "NODESCOPE_INSTANCE",
+          useFactory: async (config) => {
+            const nodescope2 = new NodeScope(config);
+            await nodescope2.initialize();
+            return nodescope2;
+          },
+          inject: ["NODESCOPE_CONFIG"]
+        },
+        {
+          provide: NodeScope,
+          useFactory: async (config) => {
+            const nodescope2 = new NodeScope(config);
+            await nodescope2.initialize();
+            return nodescope2;
+          },
+          inject: ["NODESCOPE_CONFIG"]
+        },
+        {
+          provide: NodeScopeMiddleware,
+          useFactory: (nodescope2) => new NodeScopeMiddleware(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        },
+        {
+          provide: NodeScopeInterceptor,
+          useFactory: (nodescope2) => new NodeScopeInterceptor(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        },
+        {
+          provide: NodeScopeController,
+          useFactory: (nodescope2) => new NodeScopeController(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        }
+      ],
+      exports: ["NODESCOPE_INSTANCE", NodeScope, NodeScopeMiddleware, NodeScopeInterceptor],
+      global: true
+    };
+  }
+};
+async function setupNodeScopeRoutes(app, nodescope2) {
+  const dashboardPath = nodescope2.dashboardPath;
+  const controller = new NodeScopeController(nodescope2);
+  app.getHttpAdapter().get(dashboardPath, (req, res) => {
+    return controller.getDashboard(req, res);
+  });
+  app.getHttpAdapter().all(`${dashboardPath}/api/*`, (req, res) => {
+    return controller.handleApi(req, res);
+  });
+  const httpServer = app.getHttpServer();
+  if (httpServer) {
+    import("ws").then(({ WebSocketServer }) => {
+      const wss = new WebSocketServer({ noServer: true });
+      const wsPath = `${dashboardPath}/ws`;
+      httpServer.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url || "", `http://${request.headers.host}`);
+        if (url.pathname === wsPath) {
+          wss.handleUpgrade(request, socket, head, (ws) => {
+            nodescope2.realtime.handleConnection(ws);
+            ws.on("close", () => {
+              nodescope2.realtime.handleDisconnection(ws);
+            });
+          });
+        }
+      });
+      console.log("[NodeScope] WebSocket server attached for real-time updates at", wsPath);
+    }).catch((err) => {
+      console.warn("[NodeScope] WebSocket not available, real-time updates disabled:", err.message);
+    });
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiHandler,
@@ -2895,6 +3211,10 @@ async function fastifyNodeScope(fastify, options) {
   MemoryStorage,
   MySQLStorage,
   NodeScope,
+  NodeScopeController,
+  NodeScopeInterceptor,
+  NodeScopeMiddleware,
+  NodeScopeModule,
   PostgreSQLStorage,
   QueryWatcher,
   RealTimeServer,
@@ -2920,6 +3240,7 @@ async function fastifyNodeScope(fastify, options) {
   mountExpressRoutes,
   nodescope,
   setupGlobalErrorHandlers,
+  setupNodeScopeRoutes,
   wrapFetch,
   wrapJobProcessor,
   wrapPrisma

package/dist/index.d.cts

@@ -1,6 +1,8 @@
 import * as http from 'http';
 import { RequestHandler } from 'express';
 import { Hono, MiddlewareHandler } from 'hono';
+import { ExecutionContext, CallHandler, NestMiddleware, DynamicModule } from '@nestjs/common';
+import { Observable } from 'rxjs';
 
 /**
  * Entry types that NodeScope can capture and display
@@ -919,10 +921,107 @@ declare function fastifyNodeScope(fastify: FastifyInstance, options: {
     nodescope: NodeScope;
 }): Promise<void>;
 
+/**
+ * NodeScope Middleware for NestJS
+ * Tracks HTTP requests and responses
+ *
+ * This middleware must be provided by NodeScopeModule to ensure proper DI
+ */
+declare class NodeScopeMiddleware implements NestMiddleware {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    use(req: any, res: any, next: () => void): Promise<void>;
+}
+/**
+ * NodeScope Interceptor for NestJS
+ * Alternative to middleware, provides more NestJS-native integration
+ */
+declare class NodeScopeInterceptor {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+}
+/**
+ * NodeScope Controller for NestJS
+ * Serves the dashboard and API endpoints
+ */
+declare class NodeScopeController {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    getDashboard(req: any, res: any): Promise<any>;
+    handleApi(req: any, res: any): Promise<any>;
+}
+/**
+ * NodeScope Module for NestJS
+ * Dynamic module that provides NodeScope functionality
+ */
+declare class NodeScopeModule {
+    /**
+     * Create a dynamic NestJS module for NodeScope
+     *
+     * @example
+     * ```typescript
+     * import { Module } from '@nestjs/common';
+     * import { NodeScopeModule } from '@vipin733/nodescope';
+     *
+     * @Module({
+     *   imports: [
+     *     NodeScopeModule.forRoot({
+     *       storage: 'sqlite',
+     *       dashboardPath: '/_debug',
+     *     }),
+     *   ],
+     * })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(config?: NodeScopeConfig): DynamicModule;
+    /**
+     * Create an async dynamic module
+     * Useful when you need to inject other services
+     *
+     * @example
+     * ```typescript
+     * NodeScopeModule.forRootAsync({
+     *   useFactory: (configService: ConfigService) => ({
+     *     storage: configService.get('NODESCOPE_STORAGE'),
+     *     dashboardPath: '/_debug',
+     *     enabled: configService.get('NODE_ENV') === 'development',
+     *   }),
+     *   inject: [ConfigService],
+     * })
+     * ```
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: any[]) => NodeScopeConfig | Promise<NodeScopeConfig>;
+        inject?: any[];
+    }): DynamicModule;
+}
+/**
+ * Helper function to configure NestJS routes for NodeScope dashboard
+ * Use this in your main.ts to set up dashboard routes
+ *
+ * @example
+ * ```typescript
+ * import { setupNodeScopeRoutes } from '@vipin733/nodescope';
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *
+ *   // Get NodeScope instance from app
+ *   const nodescope = app.get('NODESCOPE_INSTANCE');
+ *   await setupNodeScopeRoutes(app, nodescope);
+ *
+ *   await app.listen(3000);
+ * }
+ * ```
+ */
+declare function setupNodeScopeRoutes(app: any, nodescope: NodeScope): Promise<void>;
+
 /**
  * Get the embedded dashboard HTML
  * This is a simple HTML page that loads the dashboard React app
  */
 declare function getDashboardHtml(basePath: string): string;
 
-export { ApiHandler, BaseWatcher, type CacheEntryContent, type CacheOperation, CacheWatcher, type CacheWatcherOptions, type DumpEntryContent, type Entry, type EntryType, type EventEntryContent, EventWatcher, type EventWatcherOptions, type ExceptionEntryContent, ExceptionWatcher, type ExceptionWatcherOptions, type HttpClientEntryContent, HttpClientWatcher, type HttpClientWatcherOptions, type HttpMethod, type JobEntryContent, type JobStatus, JobWatcher, type JobWatcherOptions, type ListOptions, type LogEntryContent, type LogLevel, LogWatcher, type LogWatcherOptions, MemoryStorage, MySQLStorage, NodeScope, type NodeScopeConfig, type PaginatedResult, PostgreSQLStorage, type QueryEntryContent, QueryWatcher, type QueryWatcherOptions, RealTimeServer, type RequestContext, type RequestEntryContent, RequestWatcher, type RequestWatcherOptions, SQLiteStorage, type ScheduleEntryContent, type ScheduleWatcherOptions, type StorageAdapter, type StorageDriver, type StorageStats, TrackedEventEmitter, type WatcherConfig, attachWebSocket, createCacheWrapper, createExpressMiddleware, createHonoDashboardRoutes, createHonoMiddleware, createQueryInterceptor, createRequestContext, createStorageAdapter, fastifyNodeScope, getDashboardHtml, getDuration, getMemoryDelta, getNodeScope, initNodeScope, interceptConsole, interceptFetch, mountExpressRoutes, nodescope, setupGlobalErrorHandlers, wrapFetch, wrapJobProcessor, wrapPrisma };
+export { ApiHandler, BaseWatcher, type CacheEntryContent, type CacheOperation, CacheWatcher, type CacheWatcherOptions, type DumpEntryContent, type Entry, type EntryType, type EventEntryContent, EventWatcher, type EventWatcherOptions, type ExceptionEntryContent, ExceptionWatcher, type ExceptionWatcherOptions, type HttpClientEntryContent, HttpClientWatcher, type HttpClientWatcherOptions, type HttpMethod, type JobEntryContent, type JobStatus, JobWatcher, type JobWatcherOptions, type ListOptions, type LogEntryContent, type LogLevel, LogWatcher, type LogWatcherOptions, MemoryStorage, MySQLStorage, NodeScope, type NodeScopeConfig, NodeScopeController, NodeScopeInterceptor, NodeScopeMiddleware, NodeScopeModule, type PaginatedResult, PostgreSQLStorage, type QueryEntryContent, QueryWatcher, type QueryWatcherOptions, RealTimeServer, type RequestContext, type RequestEntryContent, RequestWatcher, type RequestWatcherOptions, SQLiteStorage, type ScheduleEntryContent, type ScheduleWatcherOptions, type StorageAdapter, type StorageDriver, type StorageStats, TrackedEventEmitter, type WatcherConfig, attachWebSocket, createCacheWrapper, createExpressMiddleware, createHonoDashboardRoutes, createHonoMiddleware, createQueryInterceptor, createRequestContext, createStorageAdapter, fastifyNodeScope, getDashboardHtml, getDuration, getMemoryDelta, getNodeScope, initNodeScope, interceptConsole, interceptFetch, mountExpressRoutes, nodescope, setupGlobalErrorHandlers, setupNodeScopeRoutes, wrapFetch, wrapJobProcessor, wrapPrisma };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import * as http from 'http';
 import { RequestHandler } from 'express';
 import { Hono, MiddlewareHandler } from 'hono';
+import { ExecutionContext, CallHandler, NestMiddleware, DynamicModule } from '@nestjs/common';
+import { Observable } from 'rxjs';
 
 /**
  * Entry types that NodeScope can capture and display
@@ -919,10 +921,107 @@ declare function fastifyNodeScope(fastify: FastifyInstance, options: {
     nodescope: NodeScope;
 }): Promise<void>;
 
+/**
+ * NodeScope Middleware for NestJS
+ * Tracks HTTP requests and responses
+ *
+ * This middleware must be provided by NodeScopeModule to ensure proper DI
+ */
+declare class NodeScopeMiddleware implements NestMiddleware {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    use(req: any, res: any, next: () => void): Promise<void>;
+}
+/**
+ * NodeScope Interceptor for NestJS
+ * Alternative to middleware, provides more NestJS-native integration
+ */
+declare class NodeScopeInterceptor {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
+}
+/**
+ * NodeScope Controller for NestJS
+ * Serves the dashboard and API endpoints
+ */
+declare class NodeScopeController {
+    private readonly nodescope;
+    constructor(nodescope: NodeScope);
+    getDashboard(req: any, res: any): Promise<any>;
+    handleApi(req: any, res: any): Promise<any>;
+}
+/**
+ * NodeScope Module for NestJS
+ * Dynamic module that provides NodeScope functionality
+ */
+declare class NodeScopeModule {
+    /**
+     * Create a dynamic NestJS module for NodeScope
+     *
+     * @example
+     * ```typescript
+     * import { Module } from '@nestjs/common';
+     * import { NodeScopeModule } from '@vipin733/nodescope';
+     *
+     * @Module({
+     *   imports: [
+     *     NodeScopeModule.forRoot({
+     *       storage: 'sqlite',
+     *       dashboardPath: '/_debug',
+     *     }),
+     *   ],
+     * })
+     * export class AppModule {}
+     * ```
+     */
+    static forRoot(config?: NodeScopeConfig): DynamicModule;
+    /**
+     * Create an async dynamic module
+     * Useful when you need to inject other services
+     *
+     * @example
+     * ```typescript
+     * NodeScopeModule.forRootAsync({
+     *   useFactory: (configService: ConfigService) => ({
+     *     storage: configService.get('NODESCOPE_STORAGE'),
+     *     dashboardPath: '/_debug',
+     *     enabled: configService.get('NODE_ENV') === 'development',
+     *   }),
+     *   inject: [ConfigService],
+     * })
+     * ```
+     */
+    static forRootAsync(options: {
+        useFactory: (...args: any[]) => NodeScopeConfig | Promise<NodeScopeConfig>;
+        inject?: any[];
+    }): DynamicModule;
+}
+/**
+ * Helper function to configure NestJS routes for NodeScope dashboard
+ * Use this in your main.ts to set up dashboard routes
+ *
+ * @example
+ * ```typescript
+ * import { setupNodeScopeRoutes } from '@vipin733/nodescope';
+ *
+ * async function bootstrap() {
+ *   const app = await NestFactory.create(AppModule);
+ *
+ *   // Get NodeScope instance from app
+ *   const nodescope = app.get('NODESCOPE_INSTANCE');
+ *   await setupNodeScopeRoutes(app, nodescope);
+ *
+ *   await app.listen(3000);
+ * }
+ * ```
+ */
+declare function setupNodeScopeRoutes(app: any, nodescope: NodeScope): Promise<void>;
+
 /**
  * Get the embedded dashboard HTML
  * This is a simple HTML page that loads the dashboard React app
  */
 declare function getDashboardHtml(basePath: string): string;
 
-export { ApiHandler, BaseWatcher, type CacheEntryContent, type CacheOperation, CacheWatcher, type CacheWatcherOptions, type DumpEntryContent, type Entry, type EntryType, type EventEntryContent, EventWatcher, type EventWatcherOptions, type ExceptionEntryContent, ExceptionWatcher, type ExceptionWatcherOptions, type HttpClientEntryContent, HttpClientWatcher, type HttpClientWatcherOptions, type HttpMethod, type JobEntryContent, type JobStatus, JobWatcher, type JobWatcherOptions, type ListOptions, type LogEntryContent, type LogLevel, LogWatcher, type LogWatcherOptions, MemoryStorage, MySQLStorage, NodeScope, type NodeScopeConfig, type PaginatedResult, PostgreSQLStorage, type QueryEntryContent, QueryWatcher, type QueryWatcherOptions, RealTimeServer, type RequestContext, type RequestEntryContent, RequestWatcher, type RequestWatcherOptions, SQLiteStorage, type ScheduleEntryContent, type ScheduleWatcherOptions, type StorageAdapter, type StorageDriver, type StorageStats, TrackedEventEmitter, type WatcherConfig, attachWebSocket, createCacheWrapper, createExpressMiddleware, createHonoDashboardRoutes, createHonoMiddleware, createQueryInterceptor, createRequestContext, createStorageAdapter, fastifyNodeScope, getDashboardHtml, getDuration, getMemoryDelta, getNodeScope, initNodeScope, interceptConsole, interceptFetch, mountExpressRoutes, nodescope, setupGlobalErrorHandlers, wrapFetch, wrapJobProcessor, wrapPrisma };
+export { ApiHandler, BaseWatcher, type CacheEntryContent, type CacheOperation, CacheWatcher, type CacheWatcherOptions, type DumpEntryContent, type Entry, type EntryType, type EventEntryContent, EventWatcher, type EventWatcherOptions, type ExceptionEntryContent, ExceptionWatcher, type ExceptionWatcherOptions, type HttpClientEntryContent, HttpClientWatcher, type HttpClientWatcherOptions, type HttpMethod, type JobEntryContent, type JobStatus, JobWatcher, type JobWatcherOptions, type ListOptions, type LogEntryContent, type LogLevel, LogWatcher, type LogWatcherOptions, MemoryStorage, MySQLStorage, NodeScope, type NodeScopeConfig, NodeScopeController, NodeScopeInterceptor, NodeScopeMiddleware, NodeScopeModule, type PaginatedResult, PostgreSQLStorage, type QueryEntryContent, QueryWatcher, type QueryWatcherOptions, RealTimeServer, type RequestContext, type RequestEntryContent, RequestWatcher, type RequestWatcherOptions, SQLiteStorage, type ScheduleEntryContent, type ScheduleWatcherOptions, type StorageAdapter, type StorageDriver, type StorageStats, TrackedEventEmitter, type WatcherConfig, attachWebSocket, createCacheWrapper, createExpressMiddleware, createHonoDashboardRoutes, createHonoMiddleware, createQueryInterceptor, createRequestContext, createStorageAdapter, fastifyNodeScope, getDashboardHtml, getDuration, getMemoryDelta, getNodeScope, initNodeScope, interceptConsole, interceptFetch, mountExpressRoutes, nodescope, setupGlobalErrorHandlers, setupNodeScopeRoutes, wrapFetch, wrapJobProcessor, wrapPrisma };

package/dist/index.js

@@ -2049,6 +2049,317 @@ async function fastifyNodeScope(fastify, options) {
     return reply.status(response.status).send(response.body);
   });
 }
+
+// src/adapters/nestjs.ts
+var NodeScopeMiddleware = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async use(req, res, next) {
+    const nodescope2 = this.nodescope;
+    if (!nodescope2 || !nodescope2.isEnabled) {
+      return next();
+    }
+    const dashboardPath = nodescope2.dashboardPath;
+    if (req.path?.startsWith(dashboardPath)) {
+      return next();
+    }
+    const ctx = nodescope2.createContext();
+    req.nodescope = ctx;
+    const originalSend = res.send;
+    const originalJson = res.json;
+    let responseBody;
+    res.send = function(body) {
+      responseBody = body;
+      return originalSend.call(this, body);
+    };
+    res.json = function(body) {
+      responseBody = body;
+      return originalJson.call(this, body);
+    };
+    res.on("finish", async () => {
+      if (!nodescope2.requestWatcher.enabled) return;
+      try {
+        const entry = nodescope2.requestWatcher.record({
+          batchId: ctx.batchId,
+          startTime: ctx.startTime,
+          method: req.method,
+          url: req.originalUrl || req.url,
+          path: req.path || req.route?.path,
+          query: req.query,
+          headers: req.headers,
+          body: req.body,
+          ip: req.ip || req.socket?.remoteAddress,
+          userAgent: req.get?.("user-agent"),
+          session: req.session,
+          response: {
+            status: res.statusCode,
+            headers: res.getHeaders?.() || {},
+            body: responseBody
+          }
+        });
+        if (entry) {
+          await nodescope2.recordEntry(entry);
+        }
+      } catch (error) {
+      }
+    });
+    next();
+  }
+};
+var NodeScopeInterceptor = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async intercept(context, next) {
+    if (!this.nodescope.isEnabled) {
+      return next.handle();
+    }
+    const http = context.switchToHttp();
+    const request = http.getRequest();
+    const response = http.getResponse();
+    const dashboardPath = this.nodescope.dashboardPath;
+    if (request.path?.startsWith(dashboardPath)) {
+      return next.handle();
+    }
+    const ctx = this.nodescope.createContext();
+    request.nodescope = ctx;
+    const { tap } = await import("rxjs/operators");
+    return next.handle().pipe(
+      tap({
+        next: async (data) => {
+          if (!this.nodescope.requestWatcher.enabled) return;
+          try {
+            const entry = this.nodescope.requestWatcher.record({
+              batchId: ctx.batchId,
+              startTime: ctx.startTime,
+              method: request.method,
+              url: request.originalUrl || request.url,
+              path: request.path || request.route?.path,
+              query: request.query,
+              headers: request.headers,
+              body: request.body,
+              ip: request.ip || request.socket?.remoteAddress,
+              userAgent: request.get?.("user-agent"),
+              session: request.session,
+              response: {
+                status: response.statusCode,
+                headers: response.getHeaders?.() || {},
+                body: data
+              }
+            });
+            if (entry) {
+              await this.nodescope.recordEntry(entry);
+            }
+          } catch (error) {
+            console.error("NodeScope error recording request:", error);
+          }
+        },
+        error: async (error) => {
+          if (!this.nodescope.exceptionWatcher.enabled) return;
+          try {
+            const errorObj = error instanceof Error ? error : new Error(String(error));
+            const entry = this.nodescope.exceptionWatcher.record({
+              error: errorObj,
+              context: {
+                method: request.method,
+                url: request.url,
+                statusCode: error.status || 500
+              }
+            });
+            if (entry) {
+              await this.nodescope.recordEntry(entry);
+            }
+          } catch (recordError) {
+            console.error("NodeScope error recording exception:", recordError);
+          }
+        }
+      })
+    );
+  }
+};
+var NodeScopeController = class {
+  constructor(nodescope2) {
+    this.nodescope = nodescope2;
+  }
+  async getDashboard(req, res) {
+    const authorized = await this.nodescope.checkAuthorization(req);
+    if (!authorized) {
+      res.status(403).json({ error: "Unauthorized" });
+      return;
+    }
+    res.setHeader("Content-Type", "text/html");
+    res.send(getDashboardHtml(this.nodescope.dashboardPath));
+  }
+  async handleApi(req, res) {
+    const authorized = await this.nodescope.checkAuthorization(req);
+    if (!authorized) {
+      res.status(403).json({ error: "Unauthorized" });
+      return;
+    }
+    const apiPath = req.path.replace(this.nodescope.dashboardPath, "");
+    const response = await this.nodescope.api.handle({
+      method: req.method,
+      url: apiPath,
+      query: req.query,
+      body: req.body
+    });
+    if (response.headers) {
+      for (const [key, value] of Object.entries(response.headers)) {
+        res.setHeader(key, value);
+      }
+    }
+    res.status(response.status).json(response.body);
+  }
+};
+var NodeScopeModule = class _NodeScopeModule {
+  /**
+   * Create a dynamic NestJS module for NodeScope
+   * 
+   * @example
+   * ```typescript
+   * import { Module } from '@nestjs/common';
+   * import { NodeScopeModule } from '@vipin733/nodescope';
+   * 
+   * @Module({
+   *   imports: [
+   *     NodeScopeModule.forRoot({
+   *       storage: 'sqlite',
+   *       dashboardPath: '/_debug',
+   *     }),
+   *   ],
+   * })
+   * export class AppModule {}
+   * ```
+   */
+  static forRoot(config = {}) {
+    const nodescope2 = new NodeScope(config);
+    nodescope2.initialize().catch((err) => {
+      console.error("Failed to initialize NodeScope:", err);
+    });
+    return {
+      module: _NodeScopeModule,
+      providers: [
+        {
+          provide: "NODESCOPE_INSTANCE",
+          useValue: nodescope2
+        },
+        {
+          provide: NodeScope,
+          useValue: nodescope2
+        },
+        {
+          provide: NodeScopeMiddleware,
+          useFactory: () => new NodeScopeMiddleware(nodescope2)
+        },
+        {
+          provide: NodeScopeInterceptor,
+          useFactory: () => new NodeScopeInterceptor(nodescope2)
+        },
+        {
+          provide: NodeScopeController,
+          useFactory: () => new NodeScopeController(nodescope2)
+        }
+      ],
+      exports: ["NODESCOPE_INSTANCE", NodeScope, NodeScopeMiddleware, NodeScopeInterceptor],
+      global: true
+    };
+  }
+  /**
+   * Create an async dynamic module
+   * Useful when you need to inject other services
+   * 
+   * @example
+   * ```typescript
+   * NodeScopeModule.forRootAsync({
+   *   useFactory: (configService: ConfigService) => ({
+   *     storage: configService.get('NODESCOPE_STORAGE'),
+   *     dashboardPath: '/_debug',
+   *     enabled: configService.get('NODE_ENV') === 'development',
+   *   }),
+   *   inject: [ConfigService],
+   * })
+   * ```
+   */
+  static forRootAsync(options) {
+    return {
+      module: _NodeScopeModule,
+      providers: [
+        {
+          provide: "NODESCOPE_CONFIG",
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
+        {
+          provide: "NODESCOPE_INSTANCE",
+          useFactory: async (config) => {
+            const nodescope2 = new NodeScope(config);
+            await nodescope2.initialize();
+            return nodescope2;
+          },
+          inject: ["NODESCOPE_CONFIG"]
+        },
+        {
+          provide: NodeScope,
+          useFactory: async (config) => {
+            const nodescope2 = new NodeScope(config);
+            await nodescope2.initialize();
+            return nodescope2;
+          },
+          inject: ["NODESCOPE_CONFIG"]
+        },
+        {
+          provide: NodeScopeMiddleware,
+          useFactory: (nodescope2) => new NodeScopeMiddleware(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        },
+        {
+          provide: NodeScopeInterceptor,
+          useFactory: (nodescope2) => new NodeScopeInterceptor(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        },
+        {
+          provide: NodeScopeController,
+          useFactory: (nodescope2) => new NodeScopeController(nodescope2),
+          inject: ["NODESCOPE_INSTANCE"]
+        }
+      ],
+      exports: ["NODESCOPE_INSTANCE", NodeScope, NodeScopeMiddleware, NodeScopeInterceptor],
+      global: true
+    };
+  }
+};
+async function setupNodeScopeRoutes(app, nodescope2) {
+  const dashboardPath = nodescope2.dashboardPath;
+  const controller = new NodeScopeController(nodescope2);
+  app.getHttpAdapter().get(dashboardPath, (req, res) => {
+    return controller.getDashboard(req, res);
+  });
+  app.getHttpAdapter().all(`${dashboardPath}/api/*`, (req, res) => {
+    return controller.handleApi(req, res);
+  });
+  const httpServer = app.getHttpServer();
+  if (httpServer) {
+    import("ws").then(({ WebSocketServer }) => {
+      const wss = new WebSocketServer({ noServer: true });
+      const wsPath = `${dashboardPath}/ws`;
+      httpServer.on("upgrade", (request, socket, head) => {
+        const url = new URL(request.url || "", `http://${request.headers.host}`);
+        if (url.pathname === wsPath) {
+          wss.handleUpgrade(request, socket, head, (ws) => {
+            nodescope2.realtime.handleConnection(ws);
+            ws.on("close", () => {
+              nodescope2.realtime.handleDisconnection(ws);
+            });
+          });
+        }
+      });
+      console.log("[NodeScope] WebSocket server attached for real-time updates at", wsPath);
+    }).catch((err) => {
+      console.warn("[NodeScope] WebSocket not available, real-time updates disabled:", err.message);
+    });
+  }
+}
 export {
   ApiHandler,
   BaseWatcher,
@@ -2061,6 +2372,10 @@ export {
   MemoryStorage,
   MySQLStorage,
   NodeScope,
+  NodeScopeController,
+  NodeScopeInterceptor,
+  NodeScopeMiddleware,
+  NodeScopeModule,
   PostgreSQLStorage,
   QueryWatcher,
   RealTimeServer,
@@ -2086,6 +2401,7 @@ export {
   mountExpressRoutes,
   nodescope,
   setupGlobalErrorHandlers,
+  setupNodeScopeRoutes,
   wrapFetch,
   wrapJobProcessor,
   wrapPrisma

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vipin733/nodescope",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "A Laravel Telescope-inspired debugging and monitoring package for Node.js and Bun applications",
   "author": "Vipin",
@@ -21,8 +21,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts --clean --external better-sqlite3 --external pg --external mysql2 --external express --external hono --external fastify",
-    "dev": "tsup src/index.ts --format cjs,esm --dts --watch --external better-sqlite3 --external pg --external mysql2 --external express --external hono --external fastify",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean --external better-sqlite3 --external pg --external mysql2 --external express --external hono --external fastify --external @nestjs/common --external rxjs",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch --external better-sqlite3 --external pg --external mysql2 --external express --external hono --external fastify --external @nestjs/common --external rxjs",
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -50,6 +50,7 @@
     "express",
     "hono",
     "fastify",
+    "nestjs",
     "observability",
     "developer-tools",
     "debug",
@@ -71,6 +72,7 @@
     "pg": "^8.11.0"
   },
   "devDependencies": {
+    "@nestjs/common": "^10.0.0",
     "@types/better-sqlite3": "^7.6.8",
     "@types/express": "^4.17.21",
     "@types/node": "^20.11.0",
@@ -81,24 +83,33 @@
     "express": "^4.18.2",
     "fastify": "^4.26.0",
     "hono": "^4.0.0",
+    "rxjs": "^7.8.0",
     "supertest": "^7.2.2",
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^1.2.0"
   },
   "peerDependencies": {
+    "@nestjs/common": ">=9.0.0",
     "express": ">=4.0.0",
     "fastify": ">=4.0.0",
-    "hono": ">=4.0.0"
+    "hono": ">=4.0.0",
+    "rxjs": ">=7.0.0"
   },
   "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    },
     "express": {
       "optional": true
     },
+    "fastify": {
+      "optional": true
+    },
     "hono": {
       "optional": true
     },
-    "fastify": {
+    "rxjs": {
       "optional": true
     }
   },