@ngn-net/nestjs-telescope 0.2.5 → 0.2.7

package/dist/telescope.module.js

@@ -35,6 +35,7 @@ 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 model_subscriber_1 = require("./watchers/model.subscriber");
 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");
@@ -246,6 +247,7 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
         }
         if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.MODEL)) {
             providers.push(model_watcher_1.ModelWatcher);
+            providers.push(model_subscriber_1.ModelSubscriber);
         }
         if (!options.enabledEntryTypes || options.enabledEntryTypes.includes(entry_type_enum_1.EntryType.NOTIFICATION)) {
             providers.push(notification_watcher_1.NotificationWatcher);
@@ -314,6 +316,11 @@ let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
         providers.push(redis_watcher_1.RedisWatcher);
         providers.push(http_client_watcher_1.HttpClientWatcher);
         providers.push(http_service_watcher_1.HttpServiceWatcher);
+        providers.push(command_watcher_1.CommandWatcher);
+        providers.push(model_watcher_1.ModelWatcher);
+        providers.push(model_subscriber_1.ModelSubscriber);
+        providers.push(notification_watcher_1.NotificationWatcher);
+        providers.push(gate_watcher_1.GateWatcher);
         // Optional modules/watchers if packages are present
         try {
             require('@nestjs/cache-manager');

package/dist/ui/manifest.json

@@ -1,5 +1,5 @@
 {
   "name": "@ngn-net/nestjs-telescope",
-  "version": "0.2.5",
-  "builtAt": "2026-06-08T12:21:55.387Z"
+  "version": "0.2.7",
+  "builtAt": "2026-06-08T12:38:36.547Z"
 }

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

@@ -67,6 +67,19 @@ let HttpClientWatcher = class HttpClientWatcher {
         this.patched = true;
         this.patch(http);
         this.patch(https);
+        // Also patch follow-redirects if used by HTTP clients like Axios
+        try {
+            const followRedirects = require('follow-redirects');
+            if (followRedirects) {
+                if (followRedirects.http)
+                    this.patch(followRedirects.http);
+                if (followRedirects.https)
+                    this.patch(followRedirects.https);
+            }
+        }
+        catch (e) {
+            // follow-redirects not available, skip
+        }
     }
     patch(module) {
         try {

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

@@ -1,12 +1,15 @@
-import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent, DataSource } from 'typeorm';
+import { OnModuleInit } from '@nestjs/common';
 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 {
+export declare class ModelSubscriber implements EntitySubscriberInterface, OnModuleInit {
     private readonly telescope;
-    constructor(telescope: TelescopeService);
+    private readonly dataSource?;
+    constructor(telescope: TelescopeService, dataSource?: DataSource | undefined);
+    onModuleInit(): void;
     listenTo(): ObjectConstructor;
     afterInsert(event: InsertEvent<any>): void;
     afterUpdate(event: UpdateEvent<any>): void;

package/dist/watchers/model.subscriber.js

@@ -8,9 +8,12 @@ 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 ModelSubscriber_1;
 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");
@@ -19,10 +22,25 @@ 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 {
+let ModelSubscriber = ModelSubscriber_1 = class ModelSubscriber {
     telescope;
-    constructor(telescope) {
+    dataSource;
+    constructor(telescope, dataSource) {
         this.telescope = telescope;
+        this.dataSource = dataSource;
+    }
+    onModuleInit() {
+        if (this.dataSource) {
+            try {
+                const alreadyRegistered = this.dataSource.subscribers.some((s) => s instanceof ModelSubscriber_1);
+                if (!alreadyRegistered) {
+                    this.dataSource.subscribers.push(this);
+                }
+            }
+            catch {
+                // Ignore registration errors
+            }
+        }
     }
     listenTo() {
         // Listen to all entities
@@ -63,8 +81,10 @@ let ModelSubscriber = class ModelSubscriber {
     }
 };
 exports.ModelSubscriber = ModelSubscriber;
-exports.ModelSubscriber = ModelSubscriber = __decorate([
+exports.ModelSubscriber = ModelSubscriber = ModelSubscriber_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])
 ], ModelSubscriber);

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

@@ -1,13 +1,9 @@
 import { OnModuleInit } from '@nestjs/common';
-import { DataSource, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { DataSource } from 'typeorm';
 import { TelescopeService } from '../telescope.service';
 export declare class QueryWatcher implements OnModuleInit {
     private readonly telescope;
     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;
-    private capture;
 }

package/dist/watchers/query.watcher.js

@@ -11,7 +11,6 @@ var __metadata = (this && this.__metadata) || function (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
@@ -19,7 +18,8 @@ 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 = QueryWatcher_1 = class QueryWatcher {
+const isWrappedSymbol = Symbol('TelescopeQueryRunnerWrapped');
+let QueryWatcher = class QueryWatcher {
     telescope;
     dataSource;
     constructor(telescope, dataSource) {
@@ -27,54 +27,141 @@ let QueryWatcher = QueryWatcher_1 = class QueryWatcher {
         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);
-                }
+        if (!this.dataSource) {
+            return;
+        }
+        try {
+            const ds = this.dataSource;
+            if (ds[isWrappedSymbol]) {
+                return;
             }
-            catch {
-                // Ignore registration errors
+            ds[isWrappedSymbol] = true;
+            const originalCreateQueryRunner = ds.createQueryRunner;
+            if (typeof originalCreateQueryRunner !== 'function') {
+                return;
             }
+            const telescope = this.telescope;
+            ds.createQueryRunner = function (...args) {
+                const queryRunner = originalCreateQueryRunner.apply(this, args);
+                if (queryRunner && typeof queryRunner.query === 'function') {
+                    const originalQuery = queryRunner.query;
+                    queryRunner.query = async function (query, parameters, useAutocommit) {
+                        // Skip tracking telescope's own queries to avoid infinite recursion/loops
+                        if (!query || query.includes('telescope_entries') || query.includes('telescope_entry')) {
+                            return originalQuery.call(this, query, parameters, useAutocommit);
+                        }
+                        const startTime = Date.now();
+                        try {
+                            const result = await originalQuery.call(this, query, parameters, useAutocommit);
+                            const duration = Date.now() - startTime;
+                            const { operation, entity } = parseSqlQuery(query);
+                            const sanitizedParams = sanitizeParameters(parameters);
+                            telescope.record({
+                                type: entry_type_enum_1.EntryType.QUERY,
+                                content: {
+                                    operation,
+                                    entity,
+                                    query,
+                                    parameters: sanitizedParams,
+                                    duration,
+                                    success: true,
+                                    connection: queryRunner.connection?.name || 'default',
+                                },
+                            }).catch(() => { });
+                            return result;
+                        }
+                        catch (error) {
+                            const duration = Date.now() - startTime;
+                            const { operation, entity } = parseSqlQuery(query);
+                            const sanitizedParams = sanitizeParameters(parameters);
+                            telescope.record({
+                                type: entry_type_enum_1.EntryType.QUERY,
+                                content: {
+                                    operation,
+                                    entity,
+                                    query,
+                                    parameters: sanitizedParams,
+                                    duration,
+                                    success: false,
+                                    error: error instanceof Error ? error.message : String(error),
+                                    connection: queryRunner.connection?.name || 'default',
+                                },
+                            }).catch(() => { });
+                            throw error;
+                        }
+                    };
+                }
+                return queryRunner;
+            };
+        }
+        catch {
+            // Ignore patching errors to protect app stability
         }
-    }
-    afterInsert(event) {
-        this.capture(event, 'INSERT');
-    }
-    afterUpdate(event) {
-        this.capture(event, 'UPDATE');
-    }
-    afterRemove(event) {
-        this.capture(event, 'REMOVE');
-    }
-    capture(event, operation) {
-        // 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: tableName || 'unknown',
-                primaryKey: event.entity?.id || null,
-                data: event.entity,
-                query: event.query,
-                parameters: event.parameters,
-            },
-        });
     }
 };
 exports.QueryWatcher = QueryWatcher;
-exports.QueryWatcher = QueryWatcher = QueryWatcher_1 = __decorate([
-    (0, typeorm_1.EventSubscriber)(),
+exports.QueryWatcher = QueryWatcher = __decorate([
     (0, common_1.Injectable)(),
     __param(1, (0, common_1.Optional)()),
     __metadata("design:paramtypes", [telescope_service_1.TelescopeService,
         typeorm_1.DataSource])
 ], QueryWatcher);
+function parseSqlQuery(query) {
+    const trimmed = query.trim();
+    const matchOp = trimmed.match(/^([a-zA-Z]+)/);
+    const operation = matchOp ? matchOp[1].toUpperCase() : 'QUERY';
+    let entity = 'db';
+    try {
+        const lowerQuery = trimmed.toLowerCase();
+        if (lowerQuery.startsWith('select')) {
+            const fromMatch = trimmed.match(/from\s+([`"']?[a-zA-Z0-9_.-]+[`"']?)/i);
+            if (fromMatch) {
+                entity = fromMatch[1].replace(/[`"']/g, '');
+            }
+        }
+        else if (lowerQuery.startsWith('insert')) {
+            const intoMatch = trimmed.match(/into\s+([`"']?[a-zA-Z0-9_.-]+[`"']?)/i);
+            if (intoMatch) {
+                entity = intoMatch[1].replace(/[`"']/g, '');
+            }
+        }
+        else if (lowerQuery.startsWith('update')) {
+            const updateMatch = trimmed.match(/update\s+([`"']?[a-zA-Z0-9_.-]+[`"']?)/i);
+            if (updateMatch) {
+                entity = updateMatch[1].replace(/[`"']/g, '');
+            }
+        }
+        else if (lowerQuery.startsWith('delete')) {
+            const deleteMatch = trimmed.match(/from\s+([`"']?[a-zA-Z0-9_.-]+[`"']?)/i);
+            if (deleteMatch) {
+                entity = deleteMatch[1].replace(/[`"']/g, '');
+            }
+        }
+    }
+    catch {
+        // Keep 'db' as fallback
+    }
+    return { operation, entity };
+}
+function sanitizeParameters(params) {
+    if (!params || !Array.isArray(params))
+        return [];
+    return params.map((param) => {
+        if (typeof param === 'bigint') {
+            return param.toString();
+        }
+        if (param instanceof Date) {
+            return param.toISOString();
+        }
+        if (param && typeof param === 'object') {
+            try {
+                JSON.stringify(param);
+                return param;
+            }
+            catch {
+                return '[Unserializable Object]';
+            }
+        }
+        return param;
+    });
+}

package/package.json

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