@node-telescope/nestjs 0.1.0

package/dist/index.js

@@ -0,0 +1,795 @@
+import { Injectable, Inject, Get, Post, Body, Delete, Param, Req, Query, Controller, UseGuards, Module, HttpException, HttpStatus } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { EntryType, HeaderFilter, runWithContext, getContext, IncomingEntry, Telescope } from '@node-telescope/core';
+export { Telescope } from '@node-telescope/core';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { WebSocketServer } from 'ws';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/telescope.constants.ts
+var TELESCOPE_OPTIONS = "TELESCOPE_OPTIONS";
+var TELESCOPE_INSTANCE = "TELESCOPE_INSTANCE";
+var MAX_RESPONSE_BODY_SIZE = 64 * 1024;
+var TelescopeInterceptor = class {
+  constructor(telescope) {
+    this.telescope = telescope;
+    this.headerFilter = new HeaderFilter(this.telescope.config.hiddenRequestHeaders);
+  }
+  headerFilter;
+  intercept(context, next) {
+    if (context.getType() !== "http") {
+      return next.handle();
+    }
+    const httpCtx = context.switchToHttp();
+    const req = httpCtx.getRequest();
+    const res = httpCtx.getResponse();
+    const requestPath = req.path || req.url;
+    if (this.telescope.shouldIgnorePath(requestPath)) {
+      return next.handle();
+    }
+    if (!this.telescope.isRecording()) {
+      return next.handle();
+    }
+    return new Observable((subscriber) => {
+      runWithContext(() => {
+        const ctx = getContext();
+        const startTime = ctx?.startTime ?? performance.now();
+        const batchId = ctx?.batchId ?? "";
+        const chunks = [];
+        let responseBodySize = 0;
+        const originalWrite = res.write.bind(res);
+        const originalEnd = res.end.bind(res);
+        res.write = function telescopeWrite(chunk, ...args) {
+          try {
+            if (chunk && responseBodySize < MAX_RESPONSE_BODY_SIZE) {
+              const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+              responseBodySize += buf.length;
+              if (responseBodySize <= MAX_RESPONSE_BODY_SIZE) {
+                chunks.push(buf);
+              }
+            }
+          } catch {
+          }
+          return originalWrite(chunk, ...args);
+        };
+        res.end = function telescopeEnd(chunk, ...args) {
+          try {
+            if (chunk && responseBodySize < MAX_RESPONSE_BODY_SIZE) {
+              const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+              responseBodySize += buf.length;
+              if (responseBodySize <= MAX_RESPONSE_BODY_SIZE) {
+                chunks.push(buf);
+              }
+            }
+          } catch {
+          }
+          return originalEnd(chunk, ...args);
+        };
+        res.on("finish", () => {
+          try {
+            if (!this.telescope.watchers.has(EntryType.Request)) return;
+            const duration = performance.now() - startTime;
+            let responseBody = null;
+            try {
+              const raw = Buffer.concat(chunks).toString("utf-8");
+              const contentType = res.getHeader("content-type");
+              if (typeof contentType === "string" && contentType.includes("application/json")) {
+                responseBody = JSON.parse(raw);
+              } else {
+                responseBody = raw;
+              }
+            } catch {
+              responseBody = "[unparseable]";
+            }
+            const filteredHeaders = this.headerFilter.filter(
+              req.headers
+            );
+            const rawResponseHeaders = res.getHeaders();
+            const responseHeaders = {};
+            for (const [key, value] of Object.entries(rawResponseHeaders)) {
+              if (typeof value === "number") {
+                responseHeaders[key] = String(value);
+              } else {
+                responseHeaders[key] = value;
+              }
+            }
+            const entry = new IncomingEntry(EntryType.Request, {
+              method: req.method,
+              url: req.originalUrl || req.url,
+              path: req.path,
+              headers: filteredHeaders,
+              payload: req.body ?? null,
+              query: req.query ?? {},
+              ipAddress: req.ip || req.socket?.remoteAddress || "unknown",
+              responseStatus: res.statusCode,
+              responseHeaders,
+              response: responseBody,
+              duration: Math.round(duration * 100) / 100,
+              memory: process.memoryUsage().heapUsed
+            });
+            entry.setBatchId(batchId);
+            this.telescope.recordEntry(entry);
+          } catch (error) {
+            console.warn("[Telescope] Error recording request:", error);
+          }
+        });
+        next.handle().pipe(
+          tap({
+            error: () => {
+            }
+          })
+        ).subscribe(subscriber);
+      });
+    });
+  }
+};
+TelescopeInterceptor = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE))
+], TelescopeInterceptor);
+var TelescopeAuthGuard = class {
+  constructor(telescope) {
+    this.telescope = telescope;
+  }
+  async canActivate(context) {
+    const gate = this.telescope.config.gate;
+    if (!gate) {
+      return true;
+    }
+    try {
+      const request = context.switchToHttp().getRequest();
+      const result = await gate(request);
+      return !!result;
+    } catch (error) {
+      console.warn("[Telescope] Gate check error:", error);
+      return false;
+    }
+  }
+};
+TelescopeAuthGuard = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE))
+], TelescopeAuthGuard);
+
+// src/telescope.controller.ts
+var ENTRY_TYPE_MAP = {
+  requests: EntryType.Request,
+  exceptions: EntryType.Exception,
+  queries: EntryType.Query,
+  logs: EntryType.Log,
+  models: EntryType.Model,
+  events: EntryType.Event,
+  jobs: EntryType.Job,
+  mail: EntryType.Mail,
+  notifications: EntryType.Notification,
+  cache: EntryType.Cache,
+  redis: EntryType.Redis,
+  gates: EntryType.Gate,
+  "http-client": EntryType.HttpClient,
+  commands: EntryType.Command,
+  schedule: EntryType.Schedule,
+  schedules: EntryType.Schedule,
+  dumps: EntryType.Dump,
+  batches: EntryType.Batch,
+  views: EntryType.View
+};
+var TelescopeController = class {
+  constructor(telescope) {
+    this.telescope = telescope;
+  }
+  getStatus() {
+    try {
+      return { recording: this.telescope.isRecording() };
+    } catch (error) {
+      console.warn("[Telescope] Status error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  toggleStatus(body) {
+    try {
+      if (typeof body?.recording === "boolean") {
+        if (body.recording) {
+          this.telescope.resume();
+        } else {
+          this.telescope.pause();
+        }
+      }
+      return { recording: this.telescope.isRecording() };
+    } catch (error) {
+      console.warn("[Telescope] Status toggle error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  async clearEntries() {
+    try {
+      const storage = this.telescope.getStorage();
+      if (!storage) {
+        throw new HttpException("Storage not available", HttpStatus.SERVICE_UNAVAILABLE);
+      }
+      await storage.truncate();
+      return { success: true };
+    } catch (error) {
+      if (error instanceof HttpException) throw error;
+      console.warn("[Telescope] Truncate error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  async getBatchEntries(id) {
+    try {
+      const storage = this.telescope.getStorage();
+      if (!storage) {
+        throw new HttpException("Storage not available", HttpStatus.SERVICE_UNAVAILABLE);
+      }
+      const entry = await storage.find(id);
+      if (!entry) {
+        throw new HttpException("Entry not found", HttpStatus.NOT_FOUND);
+      }
+      const batchEntries = await storage.findByBatchId(entry.batchId);
+      return { entries: batchEntries };
+    } catch (error) {
+      if (error instanceof HttpException) throw error;
+      console.warn("[Telescope] Batch query error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  async replayRequest(id, req) {
+    try {
+      const storage = this.telescope.getStorage();
+      if (!storage) {
+        throw new HttpException("Storage not available", HttpStatus.SERVICE_UNAVAILABLE);
+      }
+      const entry = await storage.find(id);
+      if (!entry) {
+        throw new HttpException("Entry not found", HttpStatus.NOT_FOUND);
+      }
+      if (entry.type !== EntryType.Request) {
+        throw new HttpException("Only request entries can be replayed", HttpStatus.BAD_REQUEST);
+      }
+      const content = entry.content;
+      const method = String(content["method"] ?? "GET").toUpperCase();
+      const path = String(content["path"] ?? content["url"] ?? "/");
+      const headers = content["headers"] ?? {};
+      const payload = content["payload"];
+      const host = req.get("host") ?? "localhost";
+      const protocol = req.protocol;
+      const targetUrl = `${protocol}://${host}${path}`;
+      const fetchOptions = {
+        method,
+        headers: { ...headers }
+      };
+      if (payload && method !== "GET" && method !== "HEAD") {
+        fetchOptions.body = typeof payload === "string" ? payload : JSON.stringify(payload);
+        if (!headers["content-type"]) {
+          fetchOptions.headers["content-type"] = "application/json";
+        }
+      }
+      const skipHeaders = ["host", "connection", "content-length", "transfer-encoding"];
+      for (const h of skipHeaders) {
+        delete fetchOptions.headers[h];
+      }
+      const response = await fetch(targetUrl, fetchOptions);
+      let responseBody;
+      const contentType = response.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        responseBody = await response.json();
+      } else {
+        responseBody = await response.text();
+      }
+      return {
+        success: true,
+        replay: {
+          method,
+          url: targetUrl,
+          status: response.status,
+          headers: Object.fromEntries(response.headers.entries()),
+          body: responseBody
+        }
+      };
+    } catch (error) {
+      if (error instanceof HttpException) throw error;
+      console.warn("[Telescope] Replay error:", error);
+      const message = error instanceof Error ? error.message : "Replay failed";
+      throw new HttpException(message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  async listEntries(typeParam, before, take, tag, familyHash) {
+    try {
+      const storage = this.telescope.getStorage();
+      if (!storage) {
+        throw new HttpException("Storage not available", HttpStatus.SERVICE_UNAVAILABLE);
+      }
+      const entryType = ENTRY_TYPE_MAP[typeParam];
+      if (!entryType) {
+        throw new HttpException(`Unknown entry type: ${typeParam}`, HttpStatus.BAD_REQUEST);
+      }
+      const filter = {
+        type: entryType
+      };
+      if (before) filter.beforeId = before;
+      if (take) filter.take = Math.min(parseInt(take, 10) || 50, 100);
+      else filter.take = 50;
+      if (tag) filter.tag = tag;
+      if (familyHash) filter.familyHash = familyHash;
+      return await storage.query(filter);
+    } catch (error) {
+      if (error instanceof HttpException) throw error;
+      console.warn("[Telescope] Query error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+  async getEntry(typeParam, id) {
+    try {
+      const storage = this.telescope.getStorage();
+      if (!storage) {
+        throw new HttpException("Storage not available", HttpStatus.SERVICE_UNAVAILABLE);
+      }
+      const entry = await storage.find(id);
+      if (!entry) {
+        throw new HttpException("Entry not found", HttpStatus.NOT_FOUND);
+      }
+      const expectedType = ENTRY_TYPE_MAP[typeParam];
+      if (expectedType && entry.type !== expectedType) {
+        throw new HttpException("Entry not found", HttpStatus.NOT_FOUND);
+      }
+      let batch = [];
+      try {
+        const batchEntries = await storage.findByBatchId(entry.batchId);
+        batch = batchEntries.filter((e) => e.id !== entry.id);
+      } catch {
+      }
+      return { entry, batch };
+    } catch (error) {
+      if (error instanceof HttpException) throw error;
+      console.warn("[Telescope] Entry lookup error:", error);
+      throw new HttpException("Internal server error", HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+};
+__decorateClass([
+  Get("api/status")
+], TelescopeController.prototype, "getStatus", 1);
+__decorateClass([
+  Post("api/status"),
+  __decorateParam(0, Body())
+], TelescopeController.prototype, "toggleStatus", 1);
+__decorateClass([
+  Delete("api/entries")
+], TelescopeController.prototype, "clearEntries", 1);
+__decorateClass([
+  Get("api/entries/:id/batch"),
+  __decorateParam(0, Param("id"))
+], TelescopeController.prototype, "getBatchEntries", 1);
+__decorateClass([
+  Post("api/replay/:id"),
+  __decorateParam(0, Param("id")),
+  __decorateParam(1, Req())
+], TelescopeController.prototype, "replayRequest", 1);
+__decorateClass([
+  Get("api/:type"),
+  __decorateParam(0, Param("type")),
+  __decorateParam(1, Query("before")),
+  __decorateParam(2, Query("take")),
+  __decorateParam(3, Query("tag")),
+  __decorateParam(4, Query("familyHash"))
+], TelescopeController.prototype, "listEntries", 1);
+__decorateClass([
+  Get("api/:type/:id"),
+  __decorateParam(0, Param("type")),
+  __decorateParam(1, Param("id"))
+], TelescopeController.prototype, "getEntry", 1);
+TelescopeController = __decorateClass([
+  Controller("__telescope"),
+  UseGuards(TelescopeAuthGuard),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE))
+], TelescopeController);
+var TelescopeGateway = class {
+  constructor(telescope, httpAdapterHost) {
+    this.telescope = telescope;
+    this.httpAdapterHost = httpAdapterHost;
+  }
+  wss = null;
+  entryHandler = null;
+  onModuleInit() {
+    try {
+      this.setupWebSocketServer();
+    } catch (error) {
+      console.warn("[Telescope] WebSocket setup error:", error);
+    }
+  }
+  async onModuleDestroy() {
+    try {
+      if (this.entryHandler) {
+        this.telescope.off("entry", this.entryHandler);
+        this.entryHandler = null;
+      }
+      if (this.wss) {
+        for (const client of this.wss.clients) {
+          try {
+            client.close();
+          } catch {
+          }
+        }
+        await new Promise((resolve) => {
+          this.wss.close(() => resolve());
+        });
+        this.wss = null;
+      }
+    } catch (error) {
+      console.warn("[Telescope] WebSocket cleanup error:", error);
+    }
+  }
+  setupWebSocketServer() {
+    const httpAdapter = this.httpAdapterHost?.httpAdapter;
+    if (!httpAdapter) {
+      console.warn("[Telescope] No HTTP adapter found \u2014 WebSocket server not started");
+      return;
+    }
+    const server = httpAdapter.getHttpServer();
+    if (!server) {
+      console.warn("[Telescope] No HTTP server found \u2014 WebSocket server not started");
+      return;
+    }
+    const telescopePath = this.telescope.config.path;
+    const wsPath = `${telescopePath}/ws`;
+    this.wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (request, socket, head) => {
+      try {
+        const url = new URL(
+          request.url || "",
+          `http://${request.headers["host"] || "localhost"}`
+        );
+        if (url.pathname === wsPath) {
+          this.wss.handleUpgrade(request, socket, head, (ws) => {
+            this.wss.emit("connection", ws, request);
+          });
+        }
+      } catch (error) {
+        console.warn("[Telescope] WebSocket upgrade error:", error);
+        try {
+          socket.destroy();
+        } catch {
+        }
+      }
+    });
+    this.wss.on("connection", (ws) => {
+      try {
+        ws.send(
+          JSON.stringify({ type: "connected", message: "Telescope WebSocket connected" })
+        );
+      } catch (error) {
+        console.warn("[Telescope] WebSocket welcome error:", error);
+      }
+      ws.on("error", (error) => {
+        console.warn("[Telescope] WebSocket client error:", error);
+      });
+    });
+    this.entryHandler = (entry) => {
+      try {
+        if (!this.wss || this.wss.clients.size === 0) return;
+        const message = JSON.stringify({ type: "entry", data: entry });
+        for (const client of this.wss.clients) {
+          if (client.readyState === 1) {
+            try {
+              client.send(message);
+            } catch {
+            }
+          }
+        }
+      } catch (error) {
+        console.warn("[Telescope] WebSocket broadcast error:", error);
+      }
+    };
+    this.telescope.on("entry", this.entryHandler);
+  }
+};
+TelescopeGateway = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE))
+], TelescopeGateway);
+var CSP_HEADER = [
+  "default-src 'self'",
+  "script-src 'self' 'unsafe-inline'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "font-src 'self' data:",
+  "connect-src 'self' ws: wss:"
+].join("; ");
+var FALLBACK_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Telescope Dashboard</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; background: #1a1a2e; color: #e0e0e0; }
+    .container { text-align: center; max-width: 500px; padding: 2rem; }
+    h1 { color: #7c3aed; margin-bottom: 1rem; }
+    p { line-height: 1.6; color: #a0a0b0; }
+    code { background: #2a2a3e; padding: 0.2em 0.5em; border-radius: 4px; font-size: 0.9em; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Telescope Dashboard</h1>
+    <p>The dashboard package is not installed.</p>
+    <p>Install it with:</p>
+    <p><code>npm install @node-telescope/dashboard</code></p>
+    <p>The Telescope API is still operational at the <code>/api</code> endpoints.</p>
+  </div>
+</body>
+</html>`;
+function resolveDashboardDist() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgJsonPath = require2.resolve("@node-telescope/dashboard/package.json");
+    const packageRoot = dirname(pkgJsonPath);
+    const distDir = join(packageRoot, "dist");
+    if (existsSync(join(distDir, "index.html"))) {
+      return distDir;
+    }
+    if (existsSync(join(packageRoot, "index.html"))) {
+      return packageRoot;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var TelescopeDashboardMiddleware = class {
+  constructor(telescope) {
+    this.telescope = telescope;
+    this.dashboardDist = resolveDashboardDist();
+    this.telescopePath = this.telescope.config.path;
+  }
+  dashboardDist;
+  telescopePath;
+  async use(req, res, next) {
+    try {
+      if (!req.path.startsWith(this.telescopePath)) {
+        next();
+        return;
+      }
+      const relativePath = req.path.slice(this.telescopePath.length);
+      if (relativePath.startsWith("/api")) {
+        next();
+        return;
+      }
+      res.setHeader("Content-Security-Policy", CSP_HEADER);
+      res.setHeader("X-Content-Type-Options", "nosniff");
+      res.setHeader("X-Frame-Options", "DENY");
+      if (!this.dashboardDist) {
+        res.status(200).type("html").send(FALLBACK_HTML);
+        return;
+      }
+      const filePath = relativePath || "/index.html";
+      if (filePath.includes(".") && !filePath.endsWith(".html")) {
+        const fullPath = join(this.dashboardDist, filePath);
+        if (existsSync(fullPath)) {
+          res.sendFile(fullPath);
+          return;
+        }
+        res.status(404).send("Not found");
+        return;
+      }
+      const indexPath = join(this.dashboardDist, "index.html");
+      const html = await readFile(indexPath, "utf-8");
+      res.type("html").send(html);
+    } catch (error) {
+      console.warn("[Telescope] Dashboard serve error:", error);
+      next();
+    }
+  }
+};
+TelescopeDashboardMiddleware = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE))
+], TelescopeDashboardMiddleware);
+
+// src/telescope.module.ts
+async function autoResolveStorage(config) {
+  try {
+    const { SqliteStorage } = await import('@node-telescope/storage-sqlite');
+    const storage = new SqliteStorage(config.databasePath);
+    return storage;
+  } catch {
+    return null;
+  }
+}
+var TelescopeModule = class {
+  constructor(telescope, options) {
+    this.telescope = telescope;
+    this.options = options;
+  }
+  /**
+   * Register TelescopeModule synchronously with configuration options.
+   *
+   * Usage:
+   * ```ts
+   * TelescopeModule.forRoot({ enabled: true, path: '/__telescope' })
+   * ```
+   */
+  static forRoot(config = {}) {
+    const optionsProvider = {
+      provide: TELESCOPE_OPTIONS,
+      useValue: config
+    };
+    const telescopeProvider = {
+      provide: TELESCOPE_INSTANCE,
+      useFactory: () => {
+        const telescope = new Telescope(config);
+        if (config.storage) {
+          telescope.setStorage(config.storage);
+        }
+        return telescope;
+      }
+    };
+    return {
+      module: TelescopeModule,
+      global: true,
+      providers: [
+        optionsProvider,
+        telescopeProvider,
+        TelescopeAuthGuard,
+        TelescopeGateway,
+        TelescopeDashboardMiddleware,
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: TelescopeInterceptor
+        }
+      ],
+      controllers: [TelescopeController],
+      exports: [TELESCOPE_INSTANCE, TELESCOPE_OPTIONS]
+    };
+  }
+  /**
+   * Register TelescopeModule asynchronously.
+   * Supports useFactory, useClass, and useExisting patterns.
+   *
+   * Usage:
+   * ```ts
+   * TelescopeModule.forRootAsync({
+   *   useFactory: (configService) => ({
+   *     enabled: configService.get('TELESCOPE_ENABLED'),
+   *   }),
+   *   inject: [ConfigService],
+   * })
+   * ```
+   */
+  static forRootAsync(options) {
+    const asyncProviders = TelescopeModule.createAsyncProviders(options);
+    const telescopeProvider = {
+      provide: TELESCOPE_INSTANCE,
+      useFactory: (config) => {
+        const telescope = new Telescope(config);
+        if (config.storage) {
+          telescope.setStorage(config.storage);
+        }
+        return telescope;
+      },
+      inject: [TELESCOPE_OPTIONS]
+    };
+    return {
+      module: TelescopeModule,
+      global: true,
+      imports: options.imports || [],
+      providers: [
+        ...asyncProviders,
+        telescopeProvider,
+        TelescopeAuthGuard,
+        TelescopeGateway,
+        TelescopeDashboardMiddleware,
+        {
+          provide: APP_INTERCEPTOR,
+          useClass: TelescopeInterceptor
+        }
+      ],
+      controllers: [TelescopeController],
+      exports: [TELESCOPE_INSTANCE, TELESCOPE_OPTIONS]
+    };
+  }
+  /**
+   * Configure middleware — mounts the dashboard middleware.
+   */
+  configure(consumer) {
+    const telescopePath = this.telescope.config.path;
+    consumer.apply(TelescopeDashboardMiddleware).forRoutes(`${telescopePath}`, `${telescopePath}/*`);
+  }
+  /**
+   * Lifecycle: start telescope when the module initializes.
+   * Auto-resolves storage if none was provided.
+   */
+  async onModuleInit() {
+    try {
+      if (!this.options.storage && !this.telescope.getStorage()) {
+        const storage = await autoResolveStorage(this.options);
+        if (storage) {
+          this.telescope.setStorage(storage);
+        } else {
+          console.warn(
+            "[Telescope] No storage configured. Install @node-telescope/storage-sqlite for automatic setup."
+          );
+        }
+      }
+      this.telescope.start();
+    } catch (error) {
+      console.warn("[Telescope] Module init error:", error);
+    }
+  }
+  /**
+   * Lifecycle: stop telescope when the module is destroyed.
+   */
+  async onModuleDestroy() {
+    try {
+      await this.telescope.stop();
+    } catch (error) {
+      console.warn("[Telescope] Module destroy error:", error);
+    }
+  }
+  /**
+   * Creates async providers for useFactory, useClass, or useExisting patterns.
+   */
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        {
+          provide: TELESCOPE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        }
+      ];
+    }
+    if (options.useClass) {
+      return [
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        },
+        {
+          provide: TELESCOPE_OPTIONS,
+          useFactory: async (factory) => factory.createTelescopeOptions(),
+          inject: [options.useClass]
+        }
+      ];
+    }
+    if (options.useExisting) {
+      return [
+        {
+          provide: TELESCOPE_OPTIONS,
+          useFactory: async (factory) => factory.createTelescopeOptions(),
+          inject: [options.useExisting]
+        }
+      ];
+    }
+    return [
+      {
+        provide: TELESCOPE_OPTIONS,
+        useValue: {}
+      }
+    ];
+  }
+};
+TelescopeModule = __decorateClass([
+  Module({}),
+  __decorateParam(0, Inject(TELESCOPE_INSTANCE)),
+  __decorateParam(1, Inject(TELESCOPE_OPTIONS))
+], TelescopeModule);
+
+export { TELESCOPE_INSTANCE, TELESCOPE_OPTIONS, TelescopeAuthGuard, TelescopeController, TelescopeDashboardMiddleware, TelescopeGateway, TelescopeInterceptor, TelescopeModule };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map