@ngn-net/nestjs-telescope 0.2.1 → 0.2.3

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

@@ -11,5 +11,8 @@ export declare enum EntryType {
     SCHEDULED_TASK = "scheduled_task",
     REDIS = "redis",
     GATE = "gate",
+    COMMAND = "command",
+    MODEL = "model",
+    NOTIFICATION = "notification",
     DUMP = "dump"
 }

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

@@ -16,5 +16,8 @@ var EntryType;
     EntryType["SCHEDULED_TASK"] = "scheduled_task";
     EntryType["REDIS"] = "redis";
     EntryType["GATE"] = "gate";
+    EntryType["COMMAND"] = "command";
+    EntryType["MODEL"] = "model";
+    EntryType["NOTIFICATION"] = "notification";
     EntryType["DUMP"] = "dump";
 })(EntryType || (exports.EntryType = EntryType = {}));

package/dist/index.d.ts

@@ -8,13 +8,7 @@ export * from './interfaces/entry.interface';
 export * from './guards/telescope-jwt.guard';
 export * from './constants';
 export * from './dashboard.provider';
-export * from './watchers/http-request.watcher';
-export * from './watchers/query.watcher';
-export * from './watchers/cache.watcher';
-export * from './watchers/queue.watcher';
-export * from './watchers/event.watcher';
-export * from './watchers/mail.watcher';
-export * from './watchers/log.watcher';
-export * from './watchers/exception.watcher';
-export * from './watchers/schedule.watcher';
-export * from './watchers/redis.watcher';
+export * from './watchers/command.watcher';
+export * from './watchers/model.watcher';
+export * from './watchers/notification.watcher';
+export * from './watchers/gate.watcher';

package/dist/index.js

@@ -26,13 +26,7 @@ __exportStar(require("./guards/telescope-jwt.guard"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./dashboard.provider"), exports);
 // Export all watchers for custom usage/extension
-__exportStar(require("./watchers/http-request.watcher"), exports);
-__exportStar(require("./watchers/query.watcher"), exports);
-__exportStar(require("./watchers/cache.watcher"), exports);
-__exportStar(require("./watchers/queue.watcher"), exports);
-__exportStar(require("./watchers/event.watcher"), exports);
-__exportStar(require("./watchers/mail.watcher"), exports);
-__exportStar(require("./watchers/log.watcher"), exports);
-__exportStar(require("./watchers/exception.watcher"), exports);
-__exportStar(require("./watchers/schedule.watcher"), exports);
-__exportStar(require("./watchers/redis.watcher"), exports);
+__exportStar(require("./watchers/command.watcher"), exports);
+__exportStar(require("./watchers/model.watcher"), exports);
+__exportStar(require("./watchers/notification.watcher"), exports);
+__exportStar(require("./watchers/gate.watcher"), exports);

package/dist/telescope.module.js

@@ -33,8 +33,13 @@ const mail_watcher_1 = require("./watchers/mail.watcher");
 const log_watcher_1 = require("./watchers/log.watcher");
 const exception_watcher_1 = require("./watchers/exception.watcher");
 const schedule_watcher_1 = require("./watchers/schedule.watcher");
+const http_service_watcher_1 = require("./watchers/http-service.watcher");
 const redis_watcher_1 = require("./watchers/redis.watcher");
 const telescope_jwt_guard_1 = require("./guards/telescope-jwt.guard");
+const command_watcher_1 = require("./watchers/command.watcher");
+const model_watcher_1 = require("./watchers/model.watcher");
+const notification_watcher_1 = require("./watchers/notification.watcher");
+const gate_watcher_1 = require("./watchers/gate.watcher");
 const constants_1 = require("./constants");
 const entry_type_enum_1 = require("./enums/entry-type.enum");
 let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
@@ -215,6 +220,10 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
             { type: entry_type_enum_1.EntryType.LOG, watcher: log_watcher_1.LogWatcher },
             { type: entry_type_enum_1.EntryType.EXCEPTION, watcher: exception_watcher_1.ExceptionWatcher, isInterceptor: true },
             { type: entry_type_enum_1.EntryType.REDIS, watcher: redis_watcher_1.RedisWatcher },
+            // New watchers for parity with Laravel Telescope
+            { type: entry_type_enum_1.EntryType.COMMAND, watcher: command_watcher_1.CommandWatcher },
+            { type: entry_type_enum_1.EntryType.MODEL, watcher: model_watcher_1.ModelWatcher },
+            { type: entry_type_enum_1.EntryType.NOTIFICATION, watcher: notification_watcher_1.NotificationWatcher },
         ];
         for (const item of coreWatchers) {
             if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(item.type)) {
@@ -226,6 +235,22 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
                 }
             }
         }
+        // Additional optional watchers (non-interceptors)
+        if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.HTTP_CLIENT)) {
+            providers.push(http_service_watcher_1.HttpServiceWatcher);
+        }
+        if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.COMMAND)) {
+            providers.push(command_watcher_1.CommandWatcher);
+        }
+        if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.MODEL)) {
+            providers.push(model_watcher_1.ModelWatcher);
+        }
+        if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.NOTIFICATION)) {
+            providers.push(notification_watcher_1.NotificationWatcher);
+        }
+        if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.GATE)) {
+            providers.push(gate_watcher_1.GateWatcher);
+        }
         // 2. CacheWatcher
         try {
             require('@nestjs/cache-manager');

package/dist/ui/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.2.1",
-  "builtAt": "2026-06-08T11:03:02.519Z"
+  "version": "0.2.3",
+  "builtAt": "2026-06-08T11:52:38.806Z"
 }

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

@@ -0,0 +1,13 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+/**
+ * Placeholder watcher for command execution monitoring.
+ * In a real implementation you would integrate with a command runner
+ * such as `nest-commander` or capture process events.
+ */
+export declare class CommandWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly logger;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/command.watcher.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CommandWatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandWatcher = void 0;
+// src/watchers/command.watcher.ts
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+/**
+ * Placeholder watcher for command execution monitoring.
+ * In a real implementation you would integrate with a command runner
+ * such as `nest-commander` or capture process events.
+ */
+let CommandWatcher = CommandWatcher_1 = class CommandWatcher {
+    telescope;
+    logger = new common_1.Logger(CommandWatcher_1.name);
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        // Example: record a dummy command entry when the module initializes.
+        this.telescope
+            .record({
+            type: entry_type_enum_1.EntryType.COMMAND,
+            content: {
+                command: 'module:init',
+                args: process.argv.slice(2),
+                timestamp: new Date().toISOString(),
+            },
+        })
+            .catch(() => { });
+        this.logger.debug('CommandWatcher initialized – dummy entry recorded');
+    }
+};
+exports.CommandWatcher = CommandWatcher;
+exports.CommandWatcher = CommandWatcher = CommandWatcher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], CommandWatcher);

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

@@ -0,0 +1,13 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+/**
+ * Placeholder watcher for authorization gate checks.
+ * In a full implementation you would hook into NestJS guards (CanActivate)
+ * and record the decision, user, policy, etc.
+ */
+export declare class GateWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly logger;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/gate.watcher.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var GateWatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GateWatcher = void 0;
+// src/watchers/gate.watcher.ts
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+/**
+ * Placeholder watcher for authorization gate checks.
+ * In a full implementation you would hook into NestJS guards (CanActivate)
+ * and record the decision, user, policy, etc.
+ */
+let GateWatcher = GateWatcher_1 = class GateWatcher {
+    telescope;
+    logger = new common_1.Logger(GateWatcher_1.name);
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        // Record a dummy gate entry on init for demonstration.
+        this.telescope
+            .record({
+            type: entry_type_enum_1.EntryType.GATE,
+            content: {
+                gate: 'module:init',
+                allowed: true,
+                timestamp: new Date().toISOString(),
+            },
+        })
+            .catch(() => { });
+        this.logger.debug('GateWatcher initialized – dummy entry recorded');
+    }
+};
+exports.GateWatcher = GateWatcher;
+exports.GateWatcher = GateWatcher = GateWatcher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], GateWatcher);

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

@@ -0,0 +1,14 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+import { TelescopeOptions } from '../interfaces/telescope-options.interface';
+/**
+ * Watches outbound HTTP requests made via NestJS's HttpService (axios based).
+ * It patches the HttpService prototype methods to record request/response data.
+ * The watcher is optional – it only activates if @nestjs/axios is installed.
+ */
+export declare class HttpServiceWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly options?;
+    constructor(telescope: TelescopeService, options?: TelescopeOptions | undefined);
+    onModuleInit(): void;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.HttpServiceWatcher = void 0;
+// src/watchers/http-service.watcher.ts
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+const constants_1 = require("../constants");
+/**
+ * Watches outbound HTTP requests made via NestJS's HttpService (axios based).
+ * It patches the HttpService prototype methods to record request/response data.
+ * The watcher is optional – it only activates if @nestjs/axios is installed.
+ */
+let HttpServiceWatcher = class HttpServiceWatcher {
+    telescope;
+    options;
+    constructor(telescope, options) {
+        this.telescope = telescope;
+        this.options = options;
+    }
+    onModuleInit() {
+        try {
+            const { HttpService } = require('@nestjs/axios');
+            const methods = ['get', 'post', 'put', 'delete', 'patch', 'head', 'options'];
+            for (const method of methods) {
+                if (typeof HttpService.prototype[method] !== 'function')
+                    continue;
+                const original = HttpService.prototype[method];
+                const self = this;
+                HttpService.prototype[method] = async function (...args) {
+                    const url = args[0];
+                    const config = args[1] ?? {};
+                    const start = Date.now();
+                    try {
+                        const response = await original.apply(this, args);
+                        const duration = Date.now() - start;
+                        // Record successful request
+                        self.telescope
+                            .record({
+                            type: entry_type_enum_1.EntryType.HTTP_CLIENT,
+                            content: {
+                                method: method.toUpperCase(),
+                                url,
+                                requestConfig: config,
+                                responseStatus: response?.status,
+                                responseData: response?.data,
+                                duration,
+                            },
+                        })
+                            .catch(() => { });
+                        return response;
+                    }
+                    catch (err) {
+                        const duration = Date.now() - start;
+                        self.telescope
+                            .record({
+                            type: entry_type_enum_1.EntryType.HTTP_CLIENT,
+                            content: {
+                                method: method.toUpperCase(),
+                                url,
+                                requestConfig: config,
+                                error: err?.message,
+                                duration,
+                            },
+                        })
+                            .catch(() => { });
+                        throw err;
+                    }
+                };
+            }
+        }
+        catch (e) {
+            // @nestjs/axios not installed – watcher remains inactive.
+        }
+    }
+};
+exports.HttpServiceWatcher = HttpServiceWatcher;
+exports.HttpServiceWatcher = HttpServiceWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService, Object])
+], HttpServiceWatcher);

package/dist/watchers/model.subscriber.d.ts

@@ -0,0 +1,14 @@
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { TelescopeService } from '../telescope.service';
+/**
+ * Subscribes to TypeORM entity lifecycle events and records them.
+ * This watcher is automatically registered when TypeORM is present.
+ */
+export declare class ModelSubscriber implements EntitySubscriberInterface {
+    private readonly telescope;
+    constructor(telescope: TelescopeService);
+    listenTo(): ObjectConstructor;
+    afterInsert(event: InsertEvent<any>): void;
+    afterUpdate(event: UpdateEvent<any>): void;
+    afterRemove(event: RemoveEvent<any>): void;
+}

package/dist/watchers/model.subscriber.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelSubscriber = void 0;
+// src/watchers/model.subscriber.ts
+const typeorm_1 = require("typeorm");
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+/**
+ * Subscribes to TypeORM entity lifecycle events and records them.
+ * This watcher is automatically registered when TypeORM is present.
+ */
+let ModelSubscriber = class ModelSubscriber {
+    telescope;
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    listenTo() {
+        // Listen to all entities
+        return Object;
+    }
+    afterInsert(event) {
+        this.telescope.record({
+            type: entry_type_enum_1.EntryType.MODEL,
+            content: {
+                action: 'insert',
+                entity: event.metadata.name,
+                primaryKey: event.entity?.id ?? null,
+                data: event.entity,
+            },
+        }).catch(() => { });
+    }
+    afterUpdate(event) {
+        this.telescope.record({
+            type: entry_type_enum_1.EntryType.MODEL,
+            content: {
+                action: 'update',
+                entity: event.metadata.name,
+                primaryKey: event.entity?.id ?? null,
+                updatedColumns: event.updatedColumns.map(col => col.propertyName),
+                data: event.entity,
+            },
+        }).catch(() => { });
+    }
+    afterRemove(event) {
+        this.telescope.record({
+            type: entry_type_enum_1.EntryType.MODEL,
+            content: {
+                action: 'remove',
+                entity: event.metadata.name,
+                primaryKey: event.entityId,
+            },
+        }).catch(() => { });
+    }
+};
+exports.ModelSubscriber = ModelSubscriber;
+exports.ModelSubscriber = ModelSubscriber = __decorate([
+    (0, typeorm_1.EventSubscriber)(),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], ModelSubscriber);

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

@@ -0,0 +1,12 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+/**
+ * Placeholder watcher for ORM model events (e.g., TypeORM, Mongoose, Sequelize).
+ * Real implementation would subscribe to lifecycle hooks and record create/update/delete.
+ */
+export declare class ModelWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly logger;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/model.watcher.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var ModelWatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelWatcher = void 0;
+// src/watchers/model.watcher.ts
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+/**
+ * Placeholder watcher for ORM model events (e.g., TypeORM, Mongoose, Sequelize).
+ * Real implementation would subscribe to lifecycle hooks and record create/update/delete.
+ */
+let ModelWatcher = ModelWatcher_1 = class ModelWatcher {
+    telescope;
+    logger = new common_1.Logger(ModelWatcher_1.name);
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        // Dummy entry to prove watcher registration.
+        this.telescope
+            .record({
+            type: entry_type_enum_1.EntryType.MODEL,
+            content: {
+                model: 'module:init',
+                action: 'init',
+                timestamp: new Date().toISOString(),
+            },
+        })
+            .catch(() => { });
+        this.logger.debug('ModelWatcher initialized – dummy entry recorded');
+    }
+};
+exports.ModelWatcher = ModelWatcher;
+exports.ModelWatcher = ModelWatcher = ModelWatcher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], ModelWatcher);

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

@@ -0,0 +1,13 @@
+import { OnModuleInit } from '@nestjs/common';
+import { TelescopeService } from '../telescope.service';
+/**
+ * Placeholder watcher for notification events.
+ * In a full implementation you would hook into NestJS's EventEmitter2 or any
+ * custom notification system and log the payload.
+ */
+export declare class NotificationWatcher implements OnModuleInit {
+    private readonly telescope;
+    private readonly logger;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/notification.watcher.js

@@ -0,0 +1,48 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var NotificationWatcher_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationWatcher = void 0;
+// src/watchers/notification.watcher.ts
+const common_1 = require("@nestjs/common");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+/**
+ * Placeholder watcher for notification events.
+ * In a full implementation you would hook into NestJS's EventEmitter2 or any
+ * custom notification system and log the payload.
+ */
+let NotificationWatcher = NotificationWatcher_1 = class NotificationWatcher {
+    telescope;
+    logger = new common_1.Logger(NotificationWatcher_1.name);
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        // Record a dummy notification on module init.
+        this.telescope
+            .record({
+            type: entry_type_enum_1.EntryType.NOTIFICATION,
+            content: {
+                notification: 'module:init',
+                payload: {},
+                timestamp: new Date().toISOString(),
+            },
+        })
+            .catch(() => { });
+        this.logger.debug('NotificationWatcher initialized – dummy entry recorded');
+    }
+};
+exports.NotificationWatcher = NotificationWatcher;
+exports.NotificationWatcher = NotificationWatcher = NotificationWatcher_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], NotificationWatcher);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "publishConfig": {
     "access": "public"
   },