@ngn-net/nestjs-telescope 0.1.6 → 0.1.7

package/dist/watchers/cache.watcher.d.ts

@@ -1,7 +1,8 @@
-import { Cache } from 'cache-manager';
+import { OnModuleInit } from '@nestjs/common';
 import { TelescopeService } from '../telescope.service';
-export declare class CacheWatcher {
-    private cacheManager;
+export declare class CacheWatcher implements OnModuleInit {
     private readonly telescope;
-    constructor(cacheManager: Cache, telescope: TelescopeService);
+    private cacheManager?;
+    constructor(telescope: TelescopeService, cacheManager?: any | undefined);
+    onModuleInit(): void;
 }

package/dist/watchers/cache.watcher.js

@@ -15,48 +15,64 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheWatcher = void 0;
 // src/watchers/cache.watcher.ts
 const common_1 = require("@nestjs/common");
-const cache_manager_1 = require("@nestjs/cache-manager");
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
 let CacheWatcher = class CacheWatcher {
-    cacheManager;
     telescope;
-    constructor(cacheManager, telescope) {
-        this.cacheManager = cacheManager;
+    cacheManager;
+    constructor(telescope, cacheManager) {
         this.telescope = telescope;
-        // Wrap set/get/del to capture events
-        const originalSet = this.cacheManager.set.bind(this.cacheManager);
-        const originalGet = this.cacheManager.get.bind(this.cacheManager);
-        const originalDel = this.cacheManager.del.bind(this.cacheManager);
-        this.cacheManager.set = async (key, value, ttl) => {
-            const result = await originalSet(key, value, ttl);
-            this.telescope.record({
-                type: entry_type_enum_1.EntryType.CACHE,
-                content: { action: 'SET', key, value, ttl },
-            });
-            return result;
-        };
-        this.cacheManager.get = async (key) => {
-            const value = await originalGet(key);
-            this.telescope.record({
-                type: entry_type_enum_1.EntryType.CACHE,
-                content: { action: 'GET', key, value },
-            });
-            return value;
-        };
-        this.cacheManager.del = async (key) => {
-            const result = await originalDel(key);
-            this.telescope.record({
-                type: entry_type_enum_1.EntryType.CACHE,
-                content: { action: 'DEL', key },
-            });
-            return result;
-        };
+        this.cacheManager = cacheManager;
+    }
+    onModuleInit() {
+        // Skip wrapping if no cache manager is available
+        if (!this.cacheManager)
+            return;
+        try {
+            const originalSet = this.cacheManager.set?.bind(this.cacheManager);
+            const originalGet = this.cacheManager.get?.bind(this.cacheManager);
+            const originalDel = this.cacheManager.del?.bind(this.cacheManager);
+            const telescope = this.telescope;
+            if (originalSet) {
+                this.cacheManager.set = async (key, value, ttl) => {
+                    const result = await originalSet(key, value, ttl);
+                    telescope.record({
+                        type: entry_type_enum_1.EntryType.CACHE,
+                        content: { action: 'SET', key, value, ttl },
+                    });
+                    return result;
+                };
+            }
+            if (originalGet) {
+                this.cacheManager.get = async (key) => {
+                    const value = await originalGet(key);
+                    telescope.record({
+                        type: entry_type_enum_1.EntryType.CACHE,
+                        content: { action: 'GET', key, value },
+                    });
+                    return value;
+                };
+            }
+            if (originalDel) {
+                this.cacheManager.del = async (key) => {
+                    const result = await originalDel(key);
+                    telescope.record({
+                        type: entry_type_enum_1.EntryType.CACHE,
+                        content: { action: 'DEL', key },
+                    });
+                    return result;
+                };
+            }
+        }
+        catch {
+            // Ignore errors during wrapping
+        }
     }
 };
 exports.CacheWatcher = CacheWatcher;
 exports.CacheWatcher = CacheWatcher = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
-    __metadata("design:paramtypes", [Object, telescope_service_1.TelescopeService])
+    __param(1, (0, common_1.Inject)('CACHE_MANAGER')),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService, Object])
 ], CacheWatcher);

package/dist/watchers/event.watcher.d.ts

@@ -1,13 +1,17 @@
 import { OnModuleInit } from '@nestjs/common';
-import { EventEmitter2 } from '@nestjs/event-emitter';
 import { TelescopeService } from '../telescope.service';
 /**
  * Hooks into EventEmitter2 at the 'onAny' listener level so every
  * application event is captured without requiring per-event config.
  */
 export declare class EventWatcher implements OnModuleInit {
-    private readonly emitter;
     private readonly telescope;
-    constructor(emitter: EventEmitter2, telescope: TelescopeService);
+    private emitter;
+    constructor(telescope: TelescopeService);
     onModuleInit(): void;
+    /**
+     * Called manually or via DI if EventEmitter2 is available.
+     * Use setEmitter() from the module setup to provide the emitter instance.
+     */
+    setEmitter(emitter: any): void;
 }

package/dist/watchers/event.watcher.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventWatcher = void 0;
 // src/watchers/event.watcher.ts
 const common_1 = require("@nestjs/common");
-const event_emitter_1 = require("@nestjs/event-emitter");
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
 /**
@@ -20,13 +19,31 @@ const entry_type_enum_1 = require("../enums/entry-type.enum");
  * application event is captured without requiring per-event config.
  */
 let EventWatcher = class EventWatcher {
-    emitter;
     telescope;
-    constructor(emitter, telescope) {
-        this.emitter = emitter;
+    emitter;
+    constructor(telescope) {
         this.telescope = telescope;
     }
     onModuleInit() {
+        // Dynamically resolve EventEmitter2 to avoid hard dependency
+        try {
+            const { EventEmitter2 } = require('@nestjs/event-emitter');
+            // If EventEmitter2 is available as a global/module provider, we can't inject it
+            // So we hook into it via the module system. For now, rely on the constructor injection
+            // approach but make it resilient.
+        }
+        catch {
+            // @nestjs/event-emitter not available
+        }
+    }
+    /**
+     * Called manually or via DI if EventEmitter2 is available.
+     * Use setEmitter() from the module setup to provide the emitter instance.
+     */
+    setEmitter(emitter) {
+        if (!emitter || typeof emitter.onAny !== 'function')
+            return;
+        this.emitter = emitter;
         this.emitter.onAny((event, payload) => {
             const eventName = Array.isArray(event) ? event.join('.') : event;
             // Ignore internal telescope events to avoid recursion
@@ -46,6 +63,5 @@ let EventWatcher = class EventWatcher {
 exports.EventWatcher = EventWatcher;
 exports.EventWatcher = EventWatcher = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [event_emitter_1.EventEmitter2,
-        telescope_service_1.TelescopeService])
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
 ], EventWatcher);

package/dist/watchers/exception.watcher.js

@@ -22,8 +22,8 @@ let ExceptionWatcher = class ExceptionWatcher {
         this.telescope = telescope;
     }
     intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
         return next.handle().pipe((0, operators_1.catchError)((err) => {
-            // Only record if it looks like an error
             this.telescope.record({
                 type: entry_type_enum_1.EntryType.EXCEPTION,
                 content: {
@@ -31,6 +31,12 @@ let ExceptionWatcher = class ExceptionWatcher {
                     message: err.message || String(err),
                     stack: err.stack || null,
                     status: err.status || err.statusCode || 500,
+                    // Include request context for easier debugging
+                    request: {
+                        method: request?.method,
+                        url: request?.originalUrl || request?.url,
+                        ip: request?.ip,
+                    },
                 },
             });
             return (0, rxjs_1.throwError)(() => err);

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

@@ -1,8 +1,10 @@
 import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
 import { Observable } from 'rxjs';
 import { TelescopeService } from '../telescope.service';
+import { TelescopeOptions } from '../interfaces/telescope-options.interface';
 export declare class HttpRequestWatcher implements NestInterceptor {
     private readonly telescope;
-    constructor(telescope: TelescopeService);
+    private readonly options?;
+    constructor(telescope: TelescopeService, options?: TelescopeOptions | undefined);
     intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
 }

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

@@ -8,6 +8,9 @@ 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); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpRequestWatcher = void 0;
 // src/watchers/http-request.watcher.ts
@@ -15,38 +18,52 @@ const common_1 = require("@nestjs/common");
 const operators_1 = require("rxjs/operators");
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
+const constants_1 = require("../constants");
 let HttpRequestWatcher = class HttpRequestWatcher {
     telescope;
-    constructor(telescope) {
+    options;
+    constructor(telescope, options) {
         this.telescope = telescope;
+        this.options = options;
     }
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const url = request.originalUrl || request.url || '/';
+        // Skip ignored paths
+        if (this.telescope.shouldIgnorePath(url)) {
+            return next.handle();
+        }
         const start = Date.now();
         const requestData = {
             method: request.method,
-            url: request.originalUrl,
+            url,
             headers: request.headers,
             body: request.body,
             query: request.query,
             ip: request.ip,
         };
-        return next.handle().pipe((0, operators_1.tap)((responseData) => {
+        return next.handle().pipe((0, operators_1.tap)((responseBody) => {
             const duration = Date.now() - start;
-            const entry = {
+            const statusCode = response.statusCode || 200;
+            this.telescope.record({
                 type: entry_type_enum_1.EntryType.REQUEST,
                 content: {
                     request: requestData,
-                    response: responseData,
+                    response: {
+                        statusCode,
+                        body: responseBody,
+                    },
                     duration,
                 },
-            };
-            this.telescope.record(entry);
+            });
         }));
     }
 };
 exports.HttpRequestWatcher = HttpRequestWatcher;
 exports.HttpRequestWatcher = HttpRequestWatcher = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+    __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService, Object])
 ], HttpRequestWatcher);

package/dist/watchers/log.watcher.d.ts

@@ -2,6 +2,7 @@ import { OnApplicationBootstrap } from '@nestjs/common';
 import { TelescopeService } from '../telescope.service';
 export declare class LogWatcher implements OnApplicationBootstrap {
     private readonly telescope;
+    private isRecording;
     constructor(telescope: TelescopeService);
     onApplicationBootstrap(): void;
 }

package/dist/watchers/log.watcher.js

@@ -16,42 +16,47 @@ const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
 let LogWatcher = class LogWatcher {
     telescope;
+    isRecording = false; // Guard against infinite recursion
     constructor(telescope) {
         this.telescope = telescope;
     }
     onApplicationBootstrap() {
-        // Patch the global console to capture log calls
         const originalLog = console.log.bind(console);
         const originalError = console.error.bind(console);
         const originalWarn = console.warn.bind(console);
         const originalDebug = console.debug.bind(console);
         const self = this;
+        const formatArgs = (args) => args.map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ');
+        const recordLog = (level, args) => {
+            // Guard: if we're already recording, skip to prevent infinite recursion
+            // (recording a log → save to DB → TypeORM logs → recording again → ...)
+            if (self.isRecording)
+                return;
+            self.isRecording = true;
+            try {
+                self.telescope.record({
+                    type: entry_type_enum_1.EntryType.LOG,
+                    content: { level, message: formatArgs(args) },
+                });
+            }
+            finally {
+                self.isRecording = false;
+            }
+        };
         console.log = function (...args) {
-            self.telescope.record({
-                type: entry_type_enum_1.EntryType.LOG,
-                content: { level: 'log', message: args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ') },
-            });
+            recordLog('log', args);
             return originalLog(...args);
         };
         console.error = function (...args) {
-            self.telescope.record({
-                type: entry_type_enum_1.EntryType.LOG,
-                content: { level: 'error', message: args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ') },
-            });
+            recordLog('error', args);
             return originalError(...args);
         };
         console.warn = function (...args) {
-            self.telescope.record({
-                type: entry_type_enum_1.EntryType.LOG,
-                content: { level: 'warn', message: args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ') },
-            });
+            recordLog('warn', args);
             return originalWarn(...args);
         };
         console.debug = function (...args) {
-            self.telescope.record({
-                type: entry_type_enum_1.EntryType.LOG,
-                content: { level: 'debug', message: args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ') },
-            });
+            recordLog('debug', args);
             return originalDebug(...args);
         };
     }

package/dist/watchers/mail.watcher.d.ts

@@ -3,10 +3,10 @@ import { TelescopeService } from '../telescope.service';
 /**
  * Wraps Nodemailer transport's `sendMail` method to capture outgoing e‑mails.
  * The original transport is replaced with a proxy that records each call.
+ * If nodemailer is not installed, this watcher is silently skipped.
  */
 export declare class MailWatcher implements OnModuleInit {
     private readonly telescope;
-    private originalCreateTransport;
     constructor(telescope: TelescopeService);
     onModuleInit(): void;
 }

package/dist/watchers/mail.watcher.js

@@ -1,43 +1,10 @@
 "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);
 };
@@ -45,42 +12,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MailWatcher = void 0;
 // src/watchers/mail.watcher.ts
 const common_1 = require("@nestjs/common");
-const nodemailer = __importStar(require("nodemailer"));
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
 /**
  * Wraps Nodemailer transport's `sendMail` method to capture outgoing e‑mails.
  * The original transport is replaced with a proxy that records each call.
+ * If nodemailer is not installed, this watcher is silently skipped.
  */
 let MailWatcher = class MailWatcher {
     telescope;
-    originalCreateTransport = nodemailer.createTransport;
     constructor(telescope) {
         this.telescope = telescope;
     }
     onModuleInit() {
-        const self = this;
-        // Proxy the global createTransport function
-        nodemailer.createTransport = function (...args) {
-            const transport = self.originalCreateTransport.apply(this, args);
-            const originalSendMail = transport.sendMail.bind(transport);
-            transport.sendMail = async function (mailOptions) {
-                const info = await originalSendMail(mailOptions);
-                self.telescope.record({
-                    type: entry_type_enum_1.EntryType.MAIL,
-                    content: {
-                        from: mailOptions.from,
-                        to: mailOptions.to,
-                        subject: mailOptions.subject,
-                        text: mailOptions.text,
-                        html: mailOptions.html,
-                        messageId: info.messageId,
-                    },
-                });
-                return info;
+        try {
+            const nodemailer = require('nodemailer');
+            const originalCreateTransport = nodemailer.createTransport;
+            const self = this;
+            nodemailer.createTransport = function (...args) {
+                const transport = originalCreateTransport.apply(this, args);
+                const originalSendMail = transport.sendMail.bind(transport);
+                transport.sendMail = async function (mailOptions) {
+                    const info = await originalSendMail(mailOptions);
+                    self.telescope.record({
+                        type: entry_type_enum_1.EntryType.MAIL,
+                        content: {
+                            from: mailOptions.from,
+                            to: mailOptions.to,
+                            subject: mailOptions.subject,
+                            text: mailOptions.text,
+                            html: mailOptions.html,
+                            messageId: info.messageId,
+                        },
+                    });
+                    return info;
+                };
+                return transport;
             };
-            return transport;
-        };
+        }
+        catch {
+            // nodemailer is not installed — skip silently
+        }
     }
 };
 exports.MailWatcher = MailWatcher;

package/dist/watchers/query.watcher.d.ts

@@ -1,8 +1,11 @@
-import { InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { OnModuleInit } from '@nestjs/common';
+import { DataSource, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
 import { TelescopeService } from '../telescope.service';
-export declare class QueryWatcher {
+export declare class QueryWatcher implements OnModuleInit {
     private readonly telescope;
-    constructor(telescope: TelescopeService);
+    private readonly dataSource?;
+    constructor(telescope: TelescopeService, dataSource?: DataSource | undefined);
+    onModuleInit(): void;
     afterInsert(event: InsertEvent<any>): void;
     afterUpdate(event: UpdateEvent<any>): void;
     afterRemove(event: RemoveEvent<any>): void;

package/dist/watchers/query.watcher.js

@@ -8,6 +8,10 @@ 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 QueryWatcher_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryWatcher = void 0;
 // src/watchers/query.watcher.ts
@@ -15,10 +19,29 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("typeorm");
 const telescope_service_1 = require("../telescope.service");
 const entry_type_enum_1 = require("../enums/entry-type.enum");
-let QueryWatcher = class QueryWatcher {
+let QueryWatcher = QueryWatcher_1 = class QueryWatcher {
     telescope;
-    constructor(telescope) {
+    dataSource;
+    constructor(telescope, dataSource) {
         this.telescope = telescope;
+        this.dataSource = dataSource;
+    }
+    onModuleInit() {
+        // Manually register this subscriber with the DataSource
+        // The @EventSubscriber() decorator alone doesn't auto-register when the
+        // subscriber is managed by NestJS DI rather than TypeORM's internal discovery
+        if (this.dataSource) {
+            try {
+                // Avoid duplicate registration
+                const alreadyRegistered = this.dataSource.subscribers.some((s) => s instanceof QueryWatcher_1);
+                if (!alreadyRegistered) {
+                    this.dataSource.subscribers.push(this);
+                }
+            }
+            catch {
+                // Ignore registration errors
+            }
+        }
     }
     afterInsert(event) {
         this.capture(event, 'INSERT');
@@ -30,23 +53,28 @@ let QueryWatcher = class QueryWatcher {
         this.capture(event, 'REMOVE');
     }
     capture(event, operation) {
-        const entry = {
+        // Skip recording telescope's own entity changes to avoid infinite loops
+        const tableName = event.metadata?.tableName;
+        if (tableName === 'telescope_entries')
+            return;
+        this.telescope.record({
             type: entry_type_enum_1.EntryType.QUERY,
             content: {
                 operation,
-                entity: event.metadata.tableName,
+                entity: tableName || 'unknown',
                 primaryKey: event.entity?.id || null,
                 data: event.entity,
                 query: event.query,
                 parameters: event.parameters,
             },
-        };
-        this.telescope.record(entry);
+        });
     }
 };
 exports.QueryWatcher = QueryWatcher;
-exports.QueryWatcher = QueryWatcher = __decorate([
+exports.QueryWatcher = QueryWatcher = QueryWatcher_1 = __decorate([
     (0, typeorm_1.EventSubscriber)(),
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService,
+        typeorm_1.DataSource])
 ], QueryWatcher);

package/dist/watchers/queue.watcher.d.ts

@@ -1,10 +1,8 @@
 import { OnModuleInit } from '@nestjs/common';
-import { Queue } from 'bullmq';
 import { TelescopeService } from '../telescope.service';
 export declare class QueueWatcher implements OnModuleInit {
-    private readonly queue;
     private readonly telescope;
-    private queueEvents;
-    constructor(queue: Queue, telescope: TelescopeService);
+    private readonly queue?;
+    constructor(telescope: TelescopeService, queue?: any | undefined);
     onModuleInit(): void;
 }