@ngn-net/nestjs-telescope 0.1.1

package/dist/telescope.module.js

@@ -0,0 +1,84 @@
+"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 TelescopeModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelescopeModule = void 0;
+// src/telescope.module.ts
+const common_1 = require("@nestjs/common");
+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");
+const telescope_repository_service_1 = require("./storage/telescope-repository.service");
+const telescope_entry_entity_1 = require("./storage/entities/telescope-entry.entity");
+const http_request_watcher_1 = require("./watchers/http-request.watcher");
+const query_watcher_1 = require("./watchers/query.watcher");
+const cache_watcher_1 = require("./watchers/cache.watcher");
+const queue_watcher_1 = require("./watchers/queue.watcher");
+const event_watcher_1 = require("./watchers/event.watcher");
+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 redis_watcher_1 = require("./watchers/redis.watcher");
+const telescope_jwt_guard_1 = require("./guards/telescope-jwt.guard");
+let TelescopeModule = TelescopeModule_1 = class TelescopeModule {
+    static forRoot(options = {}) {
+        return {
+            module: TelescopeModule_1,
+            imports: [
+                config_1.ConfigModule.forRoot({ isGlobal: true }),
+                typeorm_1.TypeOrmModule.forFeature([telescope_entry_entity_1.TelescopeEntry]),
+                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,
+            ],
+            controllers: [telescope_controller_1.TelescopeController],
+            exports: [telescope_service_1.TelescopeService, telescope_repository_service_1.TelescopeRepository],
+        };
+    }
+};
+exports.TelescopeModule = TelescopeModule;
+exports.TelescopeModule = TelescopeModule = TelescopeModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], TelescopeModule);

package/dist/telescope.service.d.ts

@@ -0,0 +1,13 @@
+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';
+export declare class TelescopeService implements OnModuleInit {
+    private readonly repo;
+    private readonly options?;
+    constructor(repo: TelescopeRepository, options?: any | undefined);
+    onModuleInit(): Promise<void>;
+    record(entry: Partial<TelescopeEntry> & {
+        type: EntryType;
+    }): Promise<void>;
+}

package/dist/telescope.service.js

@@ -0,0 +1,62 @@
+"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.TelescopeService = void 0;
+// src/telescope.service.ts
+const common_1 = require("@nestjs/common");
+const telescope_repository_service_1 = require("./storage/telescope-repository.service");
+let TelescopeService = class TelescopeService {
+    repo;
+    options;
+    constructor(repo, options) {
+        this.repo = repo;
+        this.options = options;
+    }
+    async onModuleInit() {
+        // ensure database schema exists (TypeORM will sync)
+    }
+    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;
+            }
+        }
+        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 (e) {
+            // Ignore database errors during pruning
+        }
+    }
+};
+exports.TelescopeService = TelescopeService;
+exports.TelescopeService = TelescopeService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)('TELESCOPE_OPTIONS')),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository, Object])
+], TelescopeService);

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

@@ -0,0 +1,7 @@
+import { Cache } from 'cache-manager';
+import { TelescopeService } from '../telescope.service';
+export declare class CacheWatcher {
+    private cacheManager;
+    private readonly telescope;
+    constructor(cacheManager: Cache, telescope: TelescopeService);
+}

package/dist/watchers/cache.watcher.js

@@ -0,0 +1,62 @@
+"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.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;
+        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;
+        };
+    }
+};
+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])
+], CacheWatcher);

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

@@ -0,0 +1,13 @@
+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);
+    onModuleInit(): void;
+}

package/dist/watchers/event.watcher.js

@@ -0,0 +1,51 @@
+"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.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");
+/**
+ * Hooks into EventEmitter2 at the 'onAny' listener level so every
+ * application event is captured without requiring per-event config.
+ */
+let EventWatcher = class EventWatcher {
+    emitter;
+    telescope;
+    constructor(emitter, telescope) {
+        this.emitter = emitter;
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        this.emitter.onAny((event, payload) => {
+            const eventName = Array.isArray(event) ? event.join('.') : event;
+            // Ignore internal telescope events to avoid recursion
+            if (eventName.startsWith('telescope.'))
+                return;
+            this.telescope.record({
+                type: entry_type_enum_1.EntryType.EVENT,
+                content: {
+                    event: eventName,
+                    payload,
+                    listeners: this.emitter.listeners(eventName).length,
+                },
+            });
+        });
+    }
+};
+exports.EventWatcher = EventWatcher;
+exports.EventWatcher = EventWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [event_emitter_1.EventEmitter2,
+        telescope_service_1.TelescopeService])
+], EventWatcher);

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

@@ -0,0 +1,8 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { TelescopeService } from '../telescope.service';
+export declare class ExceptionWatcher implements NestInterceptor {
+    private readonly telescope;
+    constructor(telescope: TelescopeService);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}

package/dist/watchers/exception.watcher.js

@@ -0,0 +1,44 @@
+"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.ExceptionWatcher = void 0;
+// src/watchers/exception.watcher.ts
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+let ExceptionWatcher = class ExceptionWatcher {
+    telescope;
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    intercept(context, next) {
+        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: {
+                    name: err.name || err.constructor?.name || 'Error',
+                    message: err.message || String(err),
+                    stack: err.stack || null,
+                    status: err.status || err.statusCode || 500,
+                },
+            });
+            return (0, rxjs_1.throwError)(() => err);
+        }));
+    }
+};
+exports.ExceptionWatcher = ExceptionWatcher;
+exports.ExceptionWatcher = ExceptionWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], ExceptionWatcher);

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

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

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

@@ -0,0 +1,52 @@
+"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.HttpRequestWatcher = void 0;
+// src/watchers/http-request.watcher.ts
+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");
+let HttpRequestWatcher = class HttpRequestWatcher {
+    telescope;
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
+        const start = Date.now();
+        const requestData = {
+            method: request.method,
+            url: request.originalUrl,
+            headers: request.headers,
+            body: request.body,
+            query: request.query,
+            ip: request.ip,
+        };
+        return next.handle().pipe((0, operators_1.tap)((responseData) => {
+            const duration = Date.now() - start;
+            const entry = {
+                type: entry_type_enum_1.EntryType.REQUEST,
+                content: {
+                    request: requestData,
+                    response: responseData,
+                    duration,
+                },
+            };
+            this.telescope.record(entry);
+        }));
+    }
+};
+exports.HttpRequestWatcher = HttpRequestWatcher;
+exports.HttpRequestWatcher = HttpRequestWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], HttpRequestWatcher);

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

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

package/dist/watchers/log.watcher.js

@@ -0,0 +1,63 @@
+"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.LogWatcher = void 0;
+// src/watchers/log.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");
+let LogWatcher = class LogWatcher {
+    telescope;
+    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;
+        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(' ') },
+            });
+            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(' ') },
+            });
+            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(' ') },
+            });
+            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(' ') },
+            });
+            return originalDebug(...args);
+        };
+    }
+};
+exports.LogWatcher = LogWatcher;
+exports.LogWatcher = LogWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], LogWatcher);

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

@@ -0,0 +1,12 @@
+import { OnModuleInit } from '@nestjs/common';
+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.
+ */
+export declare class MailWatcher implements OnModuleInit {
+    private readonly telescope;
+    private originalCreateTransport;
+    constructor(telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/mail.watcher.js

@@ -0,0 +1,90 @@
+"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);
+};
+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.
+ */
+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;
+            };
+            return transport;
+        };
+    }
+};
+exports.MailWatcher = MailWatcher;
+exports.MailWatcher = MailWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], MailWatcher);

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

@@ -0,0 +1,10 @@
+import { InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+import { TelescopeService } from '../telescope.service';
+export declare class QueryWatcher {
+    private readonly telescope;
+    constructor(telescope: TelescopeService);
+    afterInsert(event: InsertEvent<any>): void;
+    afterUpdate(event: UpdateEvent<any>): void;
+    afterRemove(event: RemoveEvent<any>): void;
+    private capture;
+}

package/dist/watchers/query.watcher.js

@@ -0,0 +1,52 @@
+"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.QueryWatcher = void 0;
+// src/watchers/query.watcher.ts
+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 {
+    telescope;
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    afterInsert(event) {
+        this.capture(event, 'INSERT');
+    }
+    afterUpdate(event) {
+        this.capture(event, 'UPDATE');
+    }
+    afterRemove(event) {
+        this.capture(event, 'REMOVE');
+    }
+    capture(event, operation) {
+        const entry = {
+            type: entry_type_enum_1.EntryType.QUERY,
+            content: {
+                operation,
+                entity: event.metadata.tableName,
+                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([
+    (0, typeorm_1.EventSubscriber)(),
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], QueryWatcher);