@ngn-net/nestjs-telescope 0.1.1

package/README.md

@@ -0,0 +1,110 @@
+# @ngn-net/nestjs-telescope
+
+A full-featured developer assistant and application monitoring suite for NestJS, inspired by Laravel Telescope. It monitors incoming HTTP requests, database queries, cache operations, background queue jobs, application events, outgoing mail, logs, unhandled exceptions, cron job schedules, and Redis commands.
+
+All telemetry records are persisted to a database table and accessible via a modern, high-fidelity dark-themed single-page application dashboard.
+
+---
+
+## Features
+
+- **HTTP Request Watcher**: Captures request methods, URLs, IP addresses, payloads, headers, durations, and response status/bodies.
+- **Database Query Watcher**: Hooks into TypeORM entity cycles (`INSERT`, `UPDATE`, `REMOVE`) to record query queries, parameters, and affected data.
+- **Cache Watcher**: Wraps Cache Manager operations (`GET`, `SET`, `DEL`) to trace cache activity.
+- **Queue Watcher**: Tracks BullMQ background jobs and captures completion values and job failures.
+- **Event Watcher**: Intercepts `EventEmitter2` events and lists firing metrics.
+- **Mail Watcher**: Proxies Nodemailer transports to log outgoing mail contents.
+- **Log Watcher**: Integrates console logs (`log`, `warn`, `error`, `debug`) directly into the dashboard.
+- **Exception Watcher**: Hooks into HTTP streams to catch and log request failures, statuses, and stack traces.
+- **Schedule Watcher**: Monitors cron execution runtimes and statuses from `@nestjs/schedule`.
+- **Redis Watcher**: Hooks into `ioredis` to report Redis command durations and arguments.
+
+---
+
+## Installation
+
+Install the package alongside its peer dependencies:
+
+```bash
+npm install @ngn-net/nestjs-telescope @nestjs/typeorm typeorm @nestjs/jwt @nestjs/passport passport-jwt
+```
+
+Ensure you have TypeORM initialized in your NestJS application.
+
+---
+
+## Usage
+
+Import the `TelescopeModule` in your root `AppModule`:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { TelescopeModule, EntryType } from '@ngn-net/nestjs-telescope';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'postgres', // or mysql, sqlite, etc.
+      host: 'localhost',
+      port: 5432,
+      username: 'db_user',
+      password: 'db_password',
+      database: 'app_db',
+      autoLoadEntities: true,
+      synchronize: true, // Telescope creates telescope_entries table automatically
+    }),
+    TelescopeModule.forRoot({
+      path: 'telescope', // Access at /telescope
+      jwtSecret: 'your-secret-key', // Secret key for authentication
+      maxEntries: 1000, // Maximum entries to retain in database
+      enabledEntryTypes: [
+        EntryType.REQUEST,
+        EntryType.QUERY,
+        EntryType.CACHE,
+        EntryType.JOB,
+        EntryType.EVENT,
+        EntryType.LOG,
+        EntryType.EXCEPTION,
+        EntryType.SCHEDULED_TASK,
+        EntryType.REDIS,
+        EntryType.MAIL,
+      ],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Authentication Configuration
+
+To secure the Telescope dashboard, configure the dashboard access password in your environment variables:
+
+```env
+TELESCOPE_PASSWORD=my-secure-password
+TELESCOPE_JWT_SECRET=super-secret-token
+```
+*If not set, the password defaults to `password`.*
+
+---
+
+## Dashboard Access
+
+1. Run your NestJS application.
+2. Open your browser and navigate to `http://localhost:3000/telescope`.
+3. Enter the password configured via `TELESCOPE_PASSWORD`.
+4. Monitor requests, logs, queries, and errors in real-time.
+
+---
+
+## Development & Test
+
+To build the package:
+```bash
+npm run build
+```
+
+To run Jest tests:
+```bash
+npm run test
+```

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const TELESCOPE_PATH: string;
+export declare const TELESCOPE_JWT_SECRET: string;
+export declare const TELESCOPE_DB_CONNECTION: string;

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELESCOPE_DB_CONNECTION = exports.TELESCOPE_JWT_SECRET = exports.TELESCOPE_PATH = void 0;
+// src/constants.ts
+exports.TELESCOPE_PATH = process.env.TELESCOPE_PATH || 'telescope';
+exports.TELESCOPE_JWT_SECRET = process.env.TELESCOPE_JWT_SECRET || 'change-me';
+exports.TELESCOPE_DB_CONNECTION = process.env.TELESCOPE_DB_CONNECTION || 'default';

package/dist/controllers/telescope.controller.d.ts

@@ -0,0 +1,17 @@
+import { TelescopeRepository } from '../storage/telescope-repository.service';
+import { JwtService } from '@nestjs/jwt';
+import { Request, Response } from 'express';
+export declare class TelescopeController {
+    private readonly repo;
+    private readonly jwtService;
+    constructor(repo: TelescopeRepository, jwtService: JwtService);
+    login(body: any): Promise<{
+        token: string;
+    }>;
+    getEntries(type?: string, search?: string, limit?: string): Promise<import("..").TelescopeEntry[]>;
+    getEntry(uuid: string): Promise<import("..").TelescopeEntry>;
+    clearEntries(): Promise<{
+        success: boolean;
+    }>;
+    serveStatic(req: Request, res: Response): void | Response<any, Record<string, any>>;
+}

package/dist/controllers/telescope.controller.js

@@ -0,0 +1,126 @@
+"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.TelescopeController = void 0;
+// src/controllers/telescope.controller.ts
+const common_1 = require("@nestjs/common");
+const telescope_repository_service_1 = require("../storage/telescope-repository.service");
+const jwt_1 = require("@nestjs/jwt");
+const telescope_jwt_guard_1 = require("../guards/telescope-jwt.guard");
+const constants_1 = require("../constants");
+const path_1 = require("path");
+const fs_1 = require("fs");
+let TelescopeController = class TelescopeController {
+    repo;
+    jwtService;
+    constructor(repo, jwtService) {
+        this.repo = repo;
+        this.jwtService = jwtService;
+    }
+    async login(body) {
+        const password = process.env.TELESCOPE_PASSWORD || 'password';
+        if (body.password === password) {
+            const payload = { username: 'telescope' };
+            return {
+                token: await this.jwtService.signAsync(payload),
+            };
+        }
+        throw new common_1.UnauthorizedException('Invalid credentials');
+    }
+    async getEntries(type, search, limit) {
+        const limitNum = limit ? parseInt(limit, 10) : 100;
+        return await this.repo.queryEntries({ type, search, limit: limitNum });
+    }
+    async getEntry(uuid) {
+        const entry = await this.repo.findByUuid(uuid);
+        if (!entry) {
+            throw new common_1.UnauthorizedException('Entry not found');
+        }
+        return entry;
+    }
+    async clearEntries() {
+        await this.repo.clearAll();
+        return { success: true };
+    }
+    // Fallback wildcard to serve static assets and UI dashboard
+    serveStatic(req, res) {
+        const rawPath = req.path;
+        // Strip TELESCOPE_PATH prefix to find the asset inside the ui directory
+        // e.g. /telescope/assets/main.js -> /assets/main.js
+        let assetPath = rawPath.replace(new RegExp(`^/${constants_1.TELESCOPE_PATH}`), '');
+        if (assetPath.startsWith('/')) {
+            assetPath = assetPath.substring(1);
+        }
+        // Default to index.html if empty or route is not file-like (support client SPA routing)
+        if (!assetPath || !assetPath.includes('.')) {
+            assetPath = 'index.html';
+        }
+        const filePath = (0, path_1.join)(__dirname, '../../ui', assetPath);
+        if ((0, fs_1.existsSync)(filePath)) {
+            return res.sendFile(filePath);
+        }
+        // Fall back to index.html
+        const fallbackPath = (0, path_1.join)(__dirname, '../../ui/index.html');
+        if ((0, fs_1.existsSync)(fallbackPath)) {
+            return res.sendFile(fallbackPath);
+        }
+        return res.status(404).send('Telescope UI files not found. Ensure build copy succeeded.');
+    }
+};
+exports.TelescopeController = TelescopeController;
+__decorate([
+    (0, common_1.Post)('api/login'),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TelescopeController.prototype, "login", null);
+__decorate([
+    (0, common_1.UseGuards)(telescope_jwt_guard_1.JwtAuthGuard),
+    (0, common_1.Get)('api/entries'),
+    __param(0, (0, common_1.Query)('type')),
+    __param(1, (0, common_1.Query)('search')),
+    __param(2, (0, common_1.Query)('limit')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], TelescopeController.prototype, "getEntries", null);
+__decorate([
+    (0, common_1.UseGuards)(telescope_jwt_guard_1.JwtAuthGuard),
+    (0, common_1.Get)('api/entries/:uuid'),
+    __param(0, (0, common_1.Param)('uuid')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TelescopeController.prototype, "getEntry", null);
+__decorate([
+    (0, common_1.UseGuards)(telescope_jwt_guard_1.JwtAuthGuard),
+    (0, common_1.Delete)('api/entries'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TelescopeController.prototype, "clearEntries", null);
+__decorate([
+    (0, common_1.Get)('*'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], TelescopeController.prototype, "serveStatic", null);
+exports.TelescopeController = TelescopeController = __decorate([
+    (0, common_1.Controller)(constants_1.TELESCOPE_PATH),
+    __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository,
+        jwt_1.JwtService])
+], TelescopeController);

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

@@ -0,0 +1,14 @@
+export declare enum EntryType {
+    REQUEST = "request",
+    QUERY = "query",
+    CACHE = "cache",
+    JOB = "job",
+    EVENT = "event",
+    MAIL = "mail",
+    LOG = "log",
+    EXCEPTION = "exception",
+    SCHEDULED_TASK = "scheduled_task",
+    REDIS = "redis",
+    GATE = "gate",
+    DUMP = "dump"
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryType = void 0;
+// src/enums/entry-type.enum.ts
+var EntryType;
+(function (EntryType) {
+    EntryType["REQUEST"] = "request";
+    EntryType["QUERY"] = "query";
+    EntryType["CACHE"] = "cache";
+    EntryType["JOB"] = "job";
+    EntryType["EVENT"] = "event";
+    EntryType["MAIL"] = "mail";
+    EntryType["LOG"] = "log";
+    EntryType["EXCEPTION"] = "exception";
+    EntryType["SCHEDULED_TASK"] = "scheduled_task";
+    EntryType["REDIS"] = "redis";
+    EntryType["GATE"] = "gate";
+    EntryType["DUMP"] = "dump";
+})(EntryType || (exports.EntryType = EntryType = {}));

package/dist/guards/telescope-jwt.guard.d.ts

@@ -0,0 +1,7 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+export declare class JwtAuthGuard implements CanActivate {
+    private readonly jwtService;
+    constructor(jwtService: JwtService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/guards/telescope-jwt.guard.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.JwtAuthGuard = void 0;
+// src/guards/telescope-jwt.guard.ts
+const common_1 = require("@nestjs/common");
+const jwt_1 = require("@nestjs/jwt");
+let JwtAuthGuard = class JwtAuthGuard {
+    jwtService;
+    constructor(jwtService) {
+        this.jwtService = jwtService;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const authHeader = request.headers['authorization'];
+        if (!authHeader)
+            throw new common_1.UnauthorizedException('Missing Authorization header');
+        const [type, token] = authHeader.split(' ');
+        if (type !== 'Bearer' || !token)
+            throw new common_1.UnauthorizedException('Invalid Authorization format');
+        try {
+            const payload = await this.jwtService.verifyAsync(token);
+            // attach payload for downstream use if needed
+            request.user = payload;
+            return true;
+        }
+        catch (err) {
+            throw new common_1.UnauthorizedException('Invalid token');
+        }
+    }
+};
+exports.JwtAuthGuard = JwtAuthGuard;
+exports.JwtAuthGuard = JwtAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [jwt_1.JwtService])
+], JwtAuthGuard);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './telescope.module';
+export * from './telescope.service';
+export * from './storage/telescope-repository.service';
+export * from './storage/entities/telescope-entry.entity';
+export * from './enums/entry-type.enum';
+export * from './interfaces/telescope-options.interface';
+export * from './interfaces/entry.interface';
+export * from './guards/telescope-jwt.guard';

package/dist/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// src/index.ts
+__exportStar(require("./telescope.module"), exports);
+__exportStar(require("./telescope.service"), exports);
+__exportStar(require("./storage/telescope-repository.service"), exports);
+__exportStar(require("./storage/entities/telescope-entry.entity"), exports);
+__exportStar(require("./enums/entry-type.enum"), exports);
+__exportStar(require("./interfaces/telescope-options.interface"), exports);
+__exportStar(require("./interfaces/entry.interface"), exports);
+__exportStar(require("./guards/telescope-jwt.guard"), exports);

package/dist/interfaces/entry.interface.d.ts

@@ -0,0 +1,10 @@
+import { EntryType } from '../enums/entry-type.enum';
+export interface ITelescopeEntry {
+    id?: number;
+    uuid: string;
+    batchId?: string;
+    type: EntryType;
+    content: Record<string, any>;
+    recordedAt: Date;
+    familyHash?: string | null;
+}

package/dist/interfaces/entry.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/telescope-options.interface.d.ts

@@ -0,0 +1,13 @@
+import { EntryType } from '../enums/entry-type.enum';
+export interface TelescopeOptions {
+    /** Base path for UI (default: /telescope) */
+    path?: string;
+    /** JWT secret used for UI authentication */
+    jwtSecret?: string;
+    /** Which entry types to enable */
+    enabledEntryTypes?: EntryType[];
+    /** Max number of entries to retain (pruning) */
+    maxEntries?: number;
+    /** Additional middleware to apply to UI routes */
+    uiMiddleware?: any[];
+}

package/dist/interfaces/telescope-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage/entities/telescope-entry.entity.d.ts

@@ -0,0 +1,10 @@
+import { EntryType } from '../../enums/entry-type.enum';
+export declare class TelescopeEntry {
+    id: number;
+    uuid: string;
+    batchId?: string;
+    type: EntryType;
+    content: Record<string, any>;
+    recordedAt: Date;
+    familyHash?: string;
+}

package/dist/storage/entities/telescope-entry.entity.js

@@ -0,0 +1,56 @@
+"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.TelescopeEntry = void 0;
+// src/storage/entities/telescope-entry.entity.ts
+const typeorm_1 = require("typeorm");
+const entry_type_enum_1 = require("../../enums/entry-type.enum");
+let TelescopeEntry = class TelescopeEntry {
+    id;
+    uuid;
+    batchId;
+    type;
+    content;
+    recordedAt;
+    familyHash;
+};
+exports.TelescopeEntry = TelescopeEntry;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)(),
+    __metadata("design:type", Number)
+], TelescopeEntry.prototype, "id", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'uuid' }),
+    __metadata("design:type", String)
+], TelescopeEntry.prototype, "uuid", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], TelescopeEntry.prototype, "batchId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'enum', enum: entry_type_enum_1.EntryType }),
+    __metadata("design:type", String)
+], TelescopeEntry.prototype, "type", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'jsonb' }),
+    __metadata("design:type", Object)
+], TelescopeEntry.prototype, "content", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)({ type: 'timestamp' }),
+    __metadata("design:type", Date)
+], TelescopeEntry.prototype, "recordedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], TelescopeEntry.prototype, "familyHash", void 0);
+exports.TelescopeEntry = TelescopeEntry = __decorate([
+    (0, typeorm_1.Entity)({ name: 'telescope_entries' })
+], TelescopeEntry);

package/dist/storage/telescope-repository.service.d.ts

@@ -0,0 +1,18 @@
+import { Repository, DeleteResult } from 'typeorm';
+import { TelescopeEntry } from './entities/telescope-entry.entity';
+import { EntryType } from '../enums/entry-type.enum';
+export declare class TelescopeRepository {
+    private readonly entryRepo;
+    constructor(entryRepo: Repository<TelescopeEntry>);
+    save(entry: Partial<TelescopeEntry>): Promise<TelescopeEntry>;
+    findAll(limit?: number): Promise<TelescopeEntry[]>;
+    findByType(type: EntryType, limit?: number): Promise<TelescopeEntry[]>;
+    prune(maxEntries: number): Promise<void>;
+    queryEntries(filters: {
+        type?: string;
+        search?: string;
+        limit?: number;
+    }): Promise<TelescopeEntry[]>;
+    findByUuid(uuid: string): Promise<TelescopeEntry | null>;
+    clearAll(): Promise<DeleteResult>;
+}

package/dist/storage/telescope-repository.service.js

@@ -0,0 +1,77 @@
+"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.TelescopeRepository = void 0;
+// src/storage/telescope-repository.service.ts
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const telescope_entry_entity_1 = require("./entities/telescope-entry.entity");
+let TelescopeRepository = class TelescopeRepository {
+    entryRepo;
+    constructor(entryRepo) {
+        this.entryRepo = entryRepo;
+    }
+    async save(entry) {
+        const ent = this.entryRepo.create(entry);
+        return await this.entryRepo.save(ent);
+    }
+    async findAll(limit = 100) {
+        return await this.entryRepo.find({ order: { recordedAt: 'DESC' }, take: limit });
+    }
+    async findByType(type, limit = 100) {
+        return await this.entryRepo.find({ where: { type }, order: { recordedAt: 'DESC' }, take: limit });
+    }
+    async prune(maxEntries) {
+        const count = await this.entryRepo.count();
+        if (count <= maxEntries)
+            return;
+        const excess = count - maxEntries;
+        const oldest = await this.entryRepo.find({ order: { recordedAt: 'ASC' }, take: excess });
+        const ids = oldest.map(e => e.id);
+        await this.entryRepo.delete(ids);
+    }
+    async queryEntries(filters) {
+        const limit = filters.limit || 100;
+        const findOptions = {
+            order: { recordedAt: 'DESC' },
+            take: limit,
+        };
+        if (filters.type) {
+            findOptions.where = { type: filters.type };
+        }
+        let entries = await this.entryRepo.find(findOptions);
+        if (filters.search) {
+            const searchLower = filters.search.toLowerCase();
+            entries = entries.filter(entry => {
+                const uuidMatch = entry.uuid.toLowerCase().includes(searchLower);
+                const contentMatch = JSON.stringify(entry.content).toLowerCase().includes(searchLower);
+                return uuidMatch || contentMatch;
+            });
+        }
+        return entries;
+    }
+    async findByUuid(uuid) {
+        return await this.entryRepo.findOne({ where: { uuid } });
+    }
+    async clearAll() {
+        return await this.entryRepo.delete({});
+    }
+};
+exports.TelescopeRepository = TelescopeRepository;
+exports.TelescopeRepository = TelescopeRepository = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(telescope_entry_entity_1.TelescopeEntry)),
+    __metadata("design:paramtypes", [typeorm_2.Repository])
+], TelescopeRepository);

package/dist/telescope.module.d.ts

@@ -0,0 +1,4 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class TelescopeModule {
+    static forRoot(options?: any): DynamicModule;
+}