@ngn-net/nestjs-telescope 0.1.6 → 0.1.8

package/dist/telescope.module.js

@@ -5,15 +5,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 var TelescopeModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelescopeModule = void 0;
 // src/telescope.module.ts
 const common_1 = require("@nestjs/common");
-const cache_manager_1 = require("@nestjs/cache-manager");
+const core_1 = require("@nestjs/core");
 const typeorm_1 = require("@nestjs/typeorm");
-const bullmq_1 = require("@nestjs/bullmq");
-const config_1 = require("@nestjs/config");
 const jwt_1 = require("@nestjs/jwt");
 const telescope_service_1 = require("./telescope.service");
 const telescope_controller_1 = require("./controllers/telescope.controller");
@@ -30,50 +31,152 @@ const exception_watcher_1 = require("./watchers/exception.watcher");
 const schedule_watcher_1 = require("./watchers/schedule.watcher");
 const redis_watcher_1 = require("./watchers/redis.watcher");
 const telescope_jwt_guard_1 = require("./guards/telescope-jwt.guard");
+const constants_1 = require("./constants");
+const entry_type_enum_1 = require("./enums/entry-type.enum");
 let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
+    moduleRef;
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
+    onModuleInit() {
+        // Dynamic EventEmitter2 configuration
+        try {
+            const eventWatcher = this.moduleRef.get(event_watcher_1.EventWatcher, { strict: false });
+            const { EventEmitter2 } = require('@nestjs/event-emitter');
+            if (eventWatcher && EventEmitter2) {
+                const emitter = this.moduleRef.get(EventEmitter2, { strict: false });
+                if (emitter) {
+                    eventWatcher.setEmitter(emitter);
+                }
+            }
+        }
+        catch (e) {
+            // EventEmitter2 or EventWatcher not registered/available
+        }
+        // Dynamic SchedulerRegistry configuration
+        try {
+            const scheduleWatcher = this.moduleRef.get(schedule_watcher_1.ScheduleWatcher, { strict: false });
+            const { SchedulerRegistry } = require('@nestjs/schedule');
+            if (scheduleWatcher && SchedulerRegistry) {
+                const scheduler = this.moduleRef.get(SchedulerRegistry, { strict: false });
+                if (scheduler) {
+                    scheduleWatcher.setSchedulerRegistry(scheduler);
+                }
+            }
+        }
+        catch (e) {
+            // SchedulerRegistry or ScheduleWatcher not registered/available
+        }
+    }
     static forRoot(options = {}) {
+        const imports = [
+            typeorm_1.TypeOrmModule.forFeature([telescope_entry_entity_1.TelescopeEntry]),
+            jwt_1.JwtModule.register({
+                secret: options.jwtSecret || process.env.TELESCOPE_JWT_SECRET || constants_1.DEFAULT_JWT_SECRET,
+                signOptions: { expiresIn: '1d' },
+            }),
+        ];
+        const providers = [
+            {
+                provide: constants_1.TELESCOPE_OPTIONS,
+                useValue: options,
+            },
+            telescope_service_1.TelescopeService,
+            telescope_repository_service_1.TelescopeRepository,
+            telescope_jwt_guard_1.JwtAuthGuard,
+        ];
+        // Always registered watchers (no external peer dependencies needed)
+        const watchersToRegister = [
+            { type: entry_type_enum_1.EntryType.REQUEST, watcher: http_request_watcher_1.HttpRequestWatcher },
+            { type: entry_type_enum_1.EntryType.QUERY, watcher: query_watcher_1.QueryWatcher },
+            { type: entry_type_enum_1.EntryType.LOG, watcher: log_watcher_1.LogWatcher },
+            { type: entry_type_enum_1.EntryType.EXCEPTION, watcher: exception_watcher_1.ExceptionWatcher },
+            { type: entry_type_enum_1.EntryType.REDIS, watcher: redis_watcher_1.RedisWatcher },
+        ];
+        for (const item of watchersToRegister) {
+            if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(item.type)) {
+                providers.push(item.watcher);
+            }
+        }
+        // Optional dependencies checking:
+        // 1. CacheWatcher (@nestjs/cache-manager)
+        let hasCache = false;
+        try {
+            require('@nestjs/cache-manager');
+            hasCache = true;
+        }
+        catch { }
+        if (hasCache && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.CACHE))) {
+            try {
+                const { CacheModule } = require('@nestjs/cache-manager');
+                if (CacheModule) {
+                    imports.push(CacheModule.register({}));
+                    providers.push(cache_watcher_1.CacheWatcher);
+                }
+            }
+            catch { }
+        }
+        // 2. QueueWatcher (@nestjs/bullmq & bullmq)
+        let hasBull = false;
+        try {
+            require('@nestjs/bullmq');
+            require('bullmq');
+            hasBull = true;
+        }
+        catch { }
+        if (hasBull && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.JOB))) {
+            try {
+                const { BullModule } = require('@nestjs/bullmq');
+                if (BullModule) {
+                    imports.push(BullModule.registerQueue({
+                        name: 'telescope-queue',
+                        connection: {
+                            host: process.env.REDIS_HOST || '127.0.0.1',
+                            port: Number(process.env.REDIS_PORT) || 6379,
+                        },
+                    }));
+                    providers.push(queue_watcher_1.QueueWatcher);
+                }
+            }
+            catch { }
+        }
+        // 3. EventWatcher (@nestjs/event-emitter)
+        let hasEvents = false;
+        try {
+            require('@nestjs/event-emitter');
+            hasEvents = true;
+        }
+        catch { }
+        if (hasEvents && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.EVENT))) {
+            providers.push(event_watcher_1.EventWatcher);
+        }
+        // 4. ScheduleWatcher (@nestjs/schedule)
+        let hasSchedule = false;
+        try {
+            require('@nestjs/schedule');
+            hasSchedule = true;
+        }
+        catch { }
+        if (hasSchedule && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.SCHEDULED_TASK))) {
+            providers.push(schedule_watcher_1.ScheduleWatcher);
+        }
+        // 5. MailWatcher (nodemailer)
+        let hasNodemailer = false;
+        try {
+            require('nodemailer');
+            hasNodemailer = true;
+        }
+        catch { }
+        if (hasNodemailer && (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.MAIL))) {
+            providers.push(mail_watcher_1.MailWatcher);
+        }
+        // Dynamic Route Prefix Setup using Reflect metadata on TelescopeController
+        const path = options.path || 'telescope';
+        Reflect.defineMetadata('path', path, telescope_controller_1.TelescopeController);
         return {
             module: TelescopeModule_1,
-            imports: [
-                config_1.ConfigModule.forRoot({ isGlobal: true }),
-                typeorm_1.TypeOrmModule.forFeature([telescope_entry_entity_1.TelescopeEntry]),
-                cache_manager_1.CacheModule.register({}),
-                bullmq_1.BullModule.registerQueue({
-                    name: 'telescope-queue',
-                    connection: {
-                        // connection settings are read from env
-                        host: process.env.REDIS_HOST || '127.0.0.1',
-                        port: Number(process.env.REDIS_PORT) || 6379,
-                    },
-                }),
-                jwt_1.JwtModule.registerAsync({
-                    imports: [config_1.ConfigModule],
-                    useFactory: async (config) => ({
-                        secret: options.jwtSecret || config.get('TELESCOPE_JWT_SECRET') || 'change-me',
-                        signOptions: { expiresIn: '1d' },
-                    }),
-                    inject: [config_1.ConfigService],
-                }),
-            ],
-            providers: [
-                {
-                    provide: 'TELESCOPE_OPTIONS',
-                    useValue: options,
-                },
-                telescope_service_1.TelescopeService,
-                telescope_repository_service_1.TelescopeRepository,
-                http_request_watcher_1.HttpRequestWatcher,
-                query_watcher_1.QueryWatcher,
-                cache_watcher_1.CacheWatcher,
-                queue_watcher_1.QueueWatcher,
-                event_watcher_1.EventWatcher,
-                mail_watcher_1.MailWatcher,
-                log_watcher_1.LogWatcher,
-                exception_watcher_1.ExceptionWatcher,
-                schedule_watcher_1.ScheduleWatcher,
-                redis_watcher_1.RedisWatcher,
-                telescope_jwt_guard_1.JwtAuthGuard,
-            ],
+            imports,
+            providers,
             controllers: [telescope_controller_1.TelescopeController],
             exports: [telescope_service_1.TelescopeService, telescope_repository_service_1.TelescopeRepository],
         };
@@ -82,5 +185,6 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
 exports.TelescopeModule = TelescopeModule;
 exports.TelescopeModule = TelescopeModule = TelescopeModule_1 = __decorate([
     (0, common_1.Global)(),
-    (0, common_1.Module)({})
+    (0, common_1.Module)({}),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
 ], TelescopeModule);

package/dist/telescope.service.d.ts

@@ -2,11 +2,31 @@ import { OnModuleInit } from '@nestjs/common';
 import { TelescopeRepository } from './storage/telescope-repository.service';
 import { TelescopeEntry } from './storage/entities/telescope-entry.entity';
 import { EntryType } from './enums/entry-type.enum';
+import { TelescopeOptions } from './interfaces/telescope-options.interface';
 export declare class TelescopeService implements OnModuleInit {
     private readonly repo;
     private readonly options?;
-    constructor(repo: TelescopeRepository, options?: any | undefined);
+    private lastPruneTime;
+    private recording;
+    constructor(repo: TelescopeRepository, options?: TelescopeOptions | undefined);
     onModuleInit(): Promise<void>;
+    /**
+     * Check if a specific entry type is enabled in the options.
+     * If `enabledEntryTypes` is not configured, all types are enabled.
+     */
+    isEnabled(type: EntryType): boolean;
+    /**
+     * Check if a request path should be ignored.
+     */
+    shouldIgnorePath(path: string): boolean;
+    /**
+     * Check if a Redis command should be ignored.
+     */
+    shouldIgnoreCommand(command: string): boolean;
+    /**
+     * Record a telescope entry. Performs type-checking, deduplication guard,
+     * and throttled pruning.
+     */
     record(entry: Partial<TelescopeEntry> & {
         type: EntryType;
     }): Promise<void>;

package/dist/telescope.service.js

@@ -16,47 +16,97 @@ exports.TelescopeService = void 0;
 // src/telescope.service.ts
 const common_1 = require("@nestjs/common");
 const telescope_repository_service_1 = require("./storage/telescope-repository.service");
+const constants_1 = require("./constants");
 let TelescopeService = class TelescopeService {
     repo;
     options;
+    lastPruneTime = 0;
+    recording = false; // Guard against recursive recording
     constructor(repo, options) {
         this.repo = repo;
         this.options = options;
     }
     async onModuleInit() {
-        // ensure database schema exists (TypeORM will sync)
+        // Module is initialized; TypeORM will handle schema sync
     }
+    /**
+     * Check if a specific entry type is enabled in the options.
+     * If `enabledEntryTypes` is not configured, all types are enabled.
+     */
+    isEnabled(type) {
+        if (!this.options?.enabledEntryTypes)
+            return true;
+        return this.options.enabledEntryTypes.includes(type);
+    }
+    /**
+     * Check if a request path should be ignored.
+     */
+    shouldIgnorePath(path) {
+        if (!path || !this.options?.ignorePaths)
+            return false;
+        const telescopePath = this.options.path || 'telescope';
+        // Always ignore telescope's own routes
+        if (path.startsWith(`/${telescopePath}`))
+            return true;
+        return this.options.ignorePaths.some((p) => path.startsWith(p));
+    }
+    /**
+     * Check if a Redis command should be ignored.
+     */
+    shouldIgnoreCommand(command) {
+        if (!command || !this.options?.ignoreCommands)
+            return false;
+        return this.options.ignoreCommands.some((c) => c.toLowerCase() === command.toLowerCase());
+    }
+    /**
+     * Record a telescope entry. Performs type-checking, deduplication guard,
+     * and throttled pruning.
+     */
     async record(entry) {
-        // Check if the type is explicitly enabled (if enabledEntryTypes is configured)
-        if (this.options?.enabledEntryTypes) {
-            if (!this.options.enabledEntryTypes.includes(entry.type)) {
-                return;
+        // Skip if this type is not enabled
+        if (!this.isEnabled(entry.type))
+            return;
+        // Guard against recursive calls (e.g., LogWatcher triggering another record)
+        if (this.recording)
+            return;
+        this.recording = true;
+        try {
+            const uuidStr = entry.uuid ?? `${Date.now()}-${Math.floor(Math.random() * 1000000)}`;
+            const fullEntry = {
+                uuid: uuidStr,
+                type: entry.type,
+                content: entry.content ?? {},
+                recordedAt: entry.recordedAt ?? new Date(),
+                familyHash: entry.familyHash ?? null,
+                batchId: entry.batchId,
+            };
+            await this.repo.save(fullEntry);
+            // Throttled pruning: at most once every PRUNE_THROTTLE_MS
+            const now = Date.now();
+            if (now - this.lastPruneTime >= constants_1.PRUNE_THROTTLE_MS) {
+                this.lastPruneTime = now;
+                const maxEntries = this.options?.maxEntries ?? constants_1.DEFAULT_MAX_ENTRIES;
+                try {
+                    await this.repo.prune(maxEntries);
+                }
+                catch {
+                    // Ignore pruning errors
+                }
             }
         }
-        const uuidStr = entry.uuid ?? `${Date.now()}-${Math.floor(Math.random() * 1000000)}`;
-        const fullEntry = {
-            uuid: uuidStr,
-            type: entry.type,
-            content: entry.content ?? {},
-            recordedAt: entry.recordedAt ?? new Date(),
-            familyHash: entry.familyHash ?? null,
-            batchId: entry.batchId,
-        };
-        await this.repo.save(fullEntry);
-        // Run pruning to stay within the limit
-        const maxEntries = this.options?.maxEntries ?? 1000;
-        try {
-            await this.repo.prune(maxEntries);
+        catch (err) {
+            // Gracefully catch all database/metadata errors to protect host app stability.
+            // Avoid using console.log here as it might trigger infinite recursion in LogWatcher.
         }
-        catch (e) {
-            // Ignore database errors during pruning
+        finally {
+            this.recording = false;
         }
     }
 };
 exports.TelescopeService = TelescopeService;
 exports.TelescopeService = TelescopeService = __decorate([
     (0, common_1.Injectable)(),
-    __param(1, (0, common_1.Inject)('TELESCOPE_OPTIONS')),
+    __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
     __param(1, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository, Object])
 ], TelescopeService);