@ngn-net/nestjs-telescope 0.2.2 → 0.2.3

package/dist/telescope.module.js

@@ -33,11 +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 {
@@ -233,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.2",
-  "builtAt": "2026-06-08T11:45:21.433Z"
+  "version": "0.2.3",
+  "builtAt": "2026-06-08T11:52:38.806Z"
 }

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/package.json

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