@ngn-net/nestjs-telescope 0.1.1

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

@@ -0,0 +1,10 @@
+import { OnModuleInit } from '@nestjs/common';
+import { Queue } from 'bullmq';
+import { TelescopeService } from '../telescope.service';
+export declare class QueueWatcher implements OnModuleInit {
+    private readonly queue;
+    private readonly telescope;
+    private queueEvents;
+    constructor(queue: Queue, telescope: TelescopeService);
+    onModuleInit(): void;
+}

package/dist/watchers/queue.watcher.js

@@ -0,0 +1,66 @@
+"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.QueueWatcher = void 0;
+// src/watchers/queue.watcher.ts
+const common_1 = require("@nestjs/common");
+const bullmq_1 = require("@nestjs/bullmq");
+const bullmq_2 = require("bullmq");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+let QueueWatcher = class QueueWatcher {
+    queue;
+    telescope;
+    queueEvents;
+    constructor(queue, telescope) {
+        this.queue = queue;
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        this.queueEvents = new bullmq_2.QueueEvents(this.queue.name, {
+            connection: this.queue.opts?.connection,
+        });
+        this.queueEvents.on('completed', ({ jobId, returnvalue }) => {
+            this.telescope.record({
+                type: entry_type_enum_1.EntryType.JOB,
+                content: { jobId, status: 'completed', returnvalue },
+            });
+        });
+        this.queueEvents.on('failed', ({ jobId, failedReason }) => {
+            this.telescope.record({
+                type: entry_type_enum_1.EntryType.JOB,
+                content: { jobId, status: 'failed', failedReason },
+            });
+        });
+        this.queueEvents.on('active', ({ jobId, prev }) => {
+            this.telescope.record({
+                type: entry_type_enum_1.EntryType.JOB,
+                content: { jobId, status: 'active', prev },
+            });
+        });
+        this.queueEvents.on('stalled', ({ jobId }) => {
+            this.telescope.record({
+                type: entry_type_enum_1.EntryType.JOB,
+                content: { jobId, status: 'stalled' },
+            });
+        });
+    }
+};
+exports.QueueWatcher = QueueWatcher;
+exports.QueueWatcher = QueueWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, bullmq_1.InjectQueue)('telescope-queue')),
+    __metadata("design:paramtypes", [bullmq_2.Queue,
+        telescope_service_1.TelescopeService])
+], QueueWatcher);

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

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

package/dist/watchers/redis.watcher.js

@@ -0,0 +1,74 @@
+"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.RedisWatcher = void 0;
+// src/watchers/redis.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 RedisWatcher = class RedisWatcher {
+    telescope;
+    constructor(telescope) {
+        this.telescope = telescope;
+    }
+    onModuleInit() {
+        try {
+            // Dynamically hook into ioredis if it is present in the workspace/runtime
+            // This prevents runtime failures if the project does not use Redis
+            const ioredis = require('ioredis');
+            if (ioredis && ioredis.prototype && ioredis.prototype.sendCommand) {
+                const originalSendCommand = ioredis.prototype.sendCommand;
+                const self = this;
+                ioredis.prototype.sendCommand = function (command, ...args) {
+                    const start = Date.now();
+                    const name = command?.name || 'unknown';
+                    const commandArgs = command?.args || [];
+                    const result = originalSendCommand.call(this, command, ...args);
+                    if (result && typeof result.then === 'function') {
+                        result.then((res) => {
+                            const duration = Date.now() - start;
+                            self.telescope.record({
+                                type: entry_type_enum_1.EntryType.REDIS,
+                                content: {
+                                    command: name,
+                                    arguments: commandArgs,
+                                    duration,
+                                    status: 'success',
+                                },
+                            });
+                        }, (err) => {
+                            const duration = Date.now() - start;
+                            self.telescope.record({
+                                type: entry_type_enum_1.EntryType.REDIS,
+                                content: {
+                                    command: name,
+                                    arguments: commandArgs,
+                                    duration,
+                                    status: 'failed',
+                                    error: err.message || String(err),
+                                },
+                            });
+                        });
+                    }
+                    return result;
+                };
+            }
+        }
+        catch (e) {
+            // ioredis is not loaded or available, skip hooking
+        }
+    }
+};
+exports.RedisWatcher = RedisWatcher;
+exports.RedisWatcher = RedisWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService])
+], RedisWatcher);

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

@@ -0,0 +1,9 @@
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { SchedulerRegistry } from '@nestjs/schedule';
+import { TelescopeService } from '../telescope.service';
+export declare class ScheduleWatcher implements OnApplicationBootstrap {
+    private readonly telescope;
+    private readonly schedulerRegistry?;
+    constructor(telescope: TelescopeService, schedulerRegistry?: SchedulerRegistry | undefined);
+    onApplicationBootstrap(): void;
+}

package/dist/watchers/schedule.watcher.js

@@ -0,0 +1,92 @@
+"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.ScheduleWatcher = void 0;
+// src/watchers/schedule.watcher.ts
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const telescope_service_1 = require("../telescope.service");
+const entry_type_enum_1 = require("../enums/entry-type.enum");
+let ScheduleWatcher = class ScheduleWatcher {
+    telescope;
+    schedulerRegistry;
+    constructor(telescope, schedulerRegistry) {
+        this.telescope = telescope;
+        this.schedulerRegistry = schedulerRegistry;
+    }
+    onApplicationBootstrap() {
+        if (!this.schedulerRegistry)
+            return;
+        try {
+            const cronJobs = this.schedulerRegistry.getCronJobs();
+            cronJobs.forEach((job, name) => {
+                // Intercept cron job execution callbacks
+                const originalCallbacks = job.callbacks || [];
+                if (originalCallbacks.length > 0) {
+                    job.callbacks = originalCallbacks.map((cb) => {
+                        return async (...args) => {
+                            const start = Date.now();
+                            this.telescope.record({
+                                type: entry_type_enum_1.EntryType.SCHEDULED_TASK,
+                                content: {
+                                    name,
+                                    status: 'running',
+                                    cronTime: job.cronTime?.toString(),
+                                },
+                            });
+                            try {
+                                const res = await cb(...args);
+                                const duration = Date.now() - start;
+                                this.telescope.record({
+                                    type: entry_type_enum_1.EntryType.SCHEDULED_TASK,
+                                    content: {
+                                        name,
+                                        status: 'completed',
+                                        duration,
+                                        cronTime: job.cronTime?.toString(),
+                                    },
+                                });
+                                return res;
+                            }
+                            catch (err) {
+                                const duration = Date.now() - start;
+                                this.telescope.record({
+                                    type: entry_type_enum_1.EntryType.SCHEDULED_TASK,
+                                    content: {
+                                        name,
+                                        status: 'failed',
+                                        duration,
+                                        error: err.message || String(err),
+                                        cronTime: job.cronTime?.toString(),
+                                    },
+                                });
+                                throw err;
+                            }
+                        };
+                    });
+                }
+            });
+        }
+        catch (e) {
+            // Ignore if schedule registry lookup fails
+        }
+    }
+};
+exports.ScheduleWatcher = ScheduleWatcher;
+exports.ScheduleWatcher = ScheduleWatcher = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [telescope_service_1.TelescopeService,
+        schedule_1.SchedulerRegistry])
+], ScheduleWatcher);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@ngn-net/nestjs-telescope",
+  "version": "0.1.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Full‑featured monitoring package for NestJS (inspired by Laravel Telescope)",
+  "author": "Generated by Antigravity",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10",
+    "@nestjs/core": "^10",
+    "@nestjs/typeorm": "^10",
+    "@nestjs/bullmq": "^10",
+    "@nestjs/config": "^3",
+    "@nestjs/jwt": "^10",
+    "@nestjs/passport": "^10",
+    "@nestjs/cache-manager": "^2",
+    "@nestjs/event-emitter": "^2",
+    "@nestjs/schedule": "^4",
+    "typeorm": "^0.3",
+    "bullmq": "^5",
+    "nodemailer": "^6",
+    "cache-manager": "^5",
+    "class-transformer": "^0.5",
+    "class-validator": "^0.14",
+    "reflect-metadata": "^0.2",
+    "passport-jwt": "^4"
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "ts-node": "^10",
+    "rimraf": "^5",
+    "jest": "^29",
+    "ts-jest": "^29",
+    "@types/jest": "^29",
+    "@types/node": "^20",
+    "@types/express": "^4.17.21",
+    "@types/nodemailer": "^6.4.15"
+  }
+}