@ngn-net/nestjs-telescope 0.2.14 → 0.3.0

package/README.md

@@ -2,16 +2,17 @@
 
 ![NestJS Telescope Banner](assets/hero.png)
 
-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.
+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, Redis commands, CLI commands, ORM model lifecycle events, notifications, and authorization gate checks.
 
-All telemetry records are persisted to a database table and accessible via a modern, high-fidelity dark-themed single-page application dashboard.
+All telemetry records are persisted to **MongoDB** (via Mongoose) for zero-impact storage that never touches your production database.
 
 ---
 
 ## 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.
+- **HTTP Client Watcher**: Patches both Node.js `http`/`https` modules and **Axios** to capture all outbound HTTP calls with full request/response data and timing.
+- **Database Query Watcher**: Hooks into TypeORM `DataSource.createQueryRunner` to record all SQL queries, parameters, durations, and success/failure status.
 - **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.
@@ -20,6 +21,41 @@ All telemetry records are persisted to a database table and accessible via a mod
 - **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.
+- **Gate (Authorization) Watcher**: Intercepts HTTP requests to record authorization decisions — successful auth checks and failed auth/forbidden errors with user context and requested roles.
+- **Command Watcher**: Records CLI command executions (startup commands like `start`, `build`, `test`, etc.) with arguments and PIDs.
+- **Model Watcher**: Subscribes to **both TypeORM** entity lifecycle events (`INSERT`, `UPDATE`, `REMOVE`) and **Mongoose** document lifecycle (`save`, `deleteOne`) to record all ORM/ODM operations.
+- **Notification Watcher**: Intercepts `EventEmitter2` events matching notification patterns (notification, mail, sms, push) and records them with channel and recipient details.
+
+---
+
+## Storage: MongoDB (Zero Production Impact)
+
+Telescope stores its telemetry data in a **dedicated MongoDB collection** (`telescope_entries`), completely separate from your application's production database.
+
+**Why MongoDB?**
+- No schema migrations or entity registration in your app
+- No foreign key constraints or connection pool contention
+- Automatic TTL-based cleanup
+- High write throughput for telemetry workloads
+- Zero impact on your production database performance
+
+### MongoDB Connection
+
+Telescope connects to MongoDB using the `MONGO_URI` environment variable, or falls back to `mongodb://localhost:27017/telescope`.
+
+```bash
+# .env
+MONGO_URI=mongodb://localhost:27017/telescope
+```
+
+Or pass the URI directly in configuration:
+
+```typescript
+TelescopeModule.forRoot({
+  mongoUri: 'mongodb://localhost:27017/telescope',
+  // ... other options
+})
+```
 
 ---
 
@@ -28,10 +64,32 @@ All telemetry records are persisted to a database table and accessible via a mod
 Install the package:
 
 ```bash
-npm install @ngn-net/nestjs-telescope @nestjs/typeorm typeorm @nestjs/jwt @nestjs/passport passport-jwt
+npm install @ngn-net/nestjs-telescope @nestjs/mongoose mongoose @nestjs/jwt @nestjs/passport passport-jwt
 ```
 
-Ensure you have TypeORM initialized in your NestJS application.
+Ensure you have `MongooseModule` initialized in your NestJS application.
+
+---
+
+## Quick Start
+
+```typescript
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TelescopeModule } from '@ngn-net/nestjs-telescope';
+
+@Module({
+  imports: [
+    MongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://localhost:27017/telescope'),
+    TelescopeModule.forRoot({
+      path: 'telescope',
+      jwtSecret: 'your-secret-key',
+      password: 'your-password',
+    }),
+  ],
+})
+export class AppModule {}
+```
 
 ---
 
@@ -39,7 +97,7 @@ Ensure you have TypeORM initialized in your NestJS application.
 
 All watchers are dynamically activated. If your application does not use certain modules, Telescope will safely boot without them. Simply install the peer dependencies for the watchers you want to enable:
 
-| Watcher | Required Dependency | Enable Entry Type |
+| Watcher | Required Dependency | Entry Type |
 |---|---|---|
 | **Cache Watcher** | `@nestjs/cache-manager` & `cache-manager` | `EntryType.CACHE` |
 | **Queue Watcher** | `@nestjs/bullmq` & `bullmq` | `EntryType.JOB` |
@@ -48,6 +106,20 @@ All watchers are dynamically activated. If your application does not use certain
 | **Mail Watcher** | `nodemailer` & `@types/nodemailer` | `EntryType.MAIL` |
 | **Redis Watcher** | `ioredis` | `EntryType.REDIS` |
 
+**Built-in watchers** (always available, no extra dependencies):
+
+| Watcher | Entry Type | What It Captures |
+|---|---|---|
+| **HTTP Request** | `EntryType.REQUEST` | Incoming HTTP requests and responses |
+| **HTTP Client** | `EntryType.HTTP_CLIENT` | Outbound HTTP calls (Node http/https + Axios) |
+| **Query** | `EntryType.QUERY` | TypeORM SQL queries |
+| **Log** | `EntryType.LOG` | Console log/warn/error/debug output |
+| **Exception** | `EntryType.EXCEPTION` | Unhandled HTTP exceptions |
+| **Gate** | `EntryType.GATE` | Authorization checks (success + failure) |
+| **Command** | `EntryType.COMMAND` | CLI command executions |
+| **Model** | `EntryType.MODEL` | TypeORM + Mongoose entity lifecycle events |
+| **Notification** | `EntryType.NOTIFICATION` | Notification events via EventEmitter2 |
+
 ---
 
 ## Configuration Reference
@@ -59,36 +131,51 @@ You can pass configuration options into `TelescopeModule.forRoot(options)`:
 | `path` | `string` | `'telescope'` | Base path for the UI and API. |
 | `jwtSecret` | `string` | `'telescope-change-me'` | JWT secret used to sign UI authentication tokens. |
 | `password` | `string` | `'password'` | Password for dashboard login (can also be set via `TELESCOPE_PASSWORD` env). |
-| `maxEntries` | `number` | `1000` | Maximum number of entries to retain in the database before pruning. |
+| `maxEntries` | `number` | `1000` | Maximum number of entries to retain before pruning. |
 | `enabledEntryTypes` | `EntryType[]` | `all` | Specific entry types to record. If undefined, all types are recorded. |
-| `ignorePaths` | `string[]` | `[]` | Specific request path prefixes to ignore (e.g. `['/health', '/metrics']`). |
-| `ignoreCommands` | `string[]` | `[]` | Specific Redis command names to ignore (e.g. `['ping', 'info']`). |
+| `ignorePaths` | `string[]` | `[]` | Request path prefixes to ignore (e.g. `['/health', '/metrics']`). |
+| `ignoreCommands` | `string[]` | `[]` | Redis command names to ignore (e.g. `['ping', 'info']`). |
 | `uiMiddleware` | `any[]` | `[]` | Custom middleware to apply to Telescope routes. |
+| `enableDashboard` | `boolean` | `true` | Enable/disable the dashboard UI. |
+| `mongoUri` | `string` | `'mongodb://localhost:27017/telescope'` | MongoDB connection URI. |
 
 ---
 
 ## Usage
 
-Import the `TelescopeModule` in your root `AppModule`:
+### Synchronous Configuration
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
+import { MongooseModule } from '@nestjs/mongoose';
 import { TelescopeModule, EntryType } from '@ngn-net/nestjs-telescope';
 
 @Module({
   imports: [
-    TypeOrmModule.forRoot({
-      type: 'sqlite', // or postgres, mysql, etc.
-      database: 'app.db',
-      autoLoadEntities: true,
-      synchronize: true, // Telescope automatically registers its own entity
-    }),
+    MongooseModule.forRoot(process.env.MONGO_URI || 'mongodb://localhost:27017/myapp'),
     TelescopeModule.forRoot({
-      path: 'telescope', // Access at /telescope
+      path: 'telescope',
       password: 'my-secure-password',
+      jwtSecret: 'my-jwt-secret',
       maxEntries: 500,
       ignorePaths: ['/health-check'],
+      enabledEntryTypes: [
+        EntryType.REQUEST,
+        EntryType.HTTP_CLIENT,
+        EntryType.QUERY,
+        EntryType.CACHE,
+        EntryType.JOB,
+        EntryType.EVENT,
+        EntryType.LOG,
+        EntryType.EXCEPTION,
+        EntryType.SCHEDULED_TASK,
+        EntryType.REDIS,
+        EntryType.MAIL,
+        EntryType.GATE,
+        EntryType.COMMAND,
+        EntryType.MODEL,
+        EntryType.NOTIFICATION,
+      ],
     }),
   ],
 })
@@ -97,8 +184,6 @@ export class AppModule {}
 
 ### Async Configuration
 
-You can also register `TelescopeModule` asynchronously using a factory (e.g. inject `ConfigService`):
-
 ```typescript
 import { Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
@@ -133,6 +218,47 @@ export class AppModule {}
 
 ---
 
+## Entry Types
+
+All available entry types for filtering and configuration:
+
+```typescript
+import { EntryType } from '@ngn-net/nestjs-telescope';
+
+EntryType.REQUEST          // Incoming HTTP requests
+EntryType.HTTP_CLIENT      // Outbound HTTP calls (http/https/Axios)
+EntryType.QUERY            // Database queries (TypeORM)
+EntryType.CACHE            // Cache operations
+EntryType.JOB              // Background queue jobs (BullMQ)
+EntryType.EVENT            // Application events (EventEmitter2)
+EntryType.MAIL             // Outgoing emails
+EntryType.LOG              // Console log output
+EntryType.EXCEPTION        // Unhandled exceptions
+EntryType.SCHEDULED_TASK   // Cron/scheduled task executions
+EntryType.REDIS            // Redis commands
+EntryType.GATE             // Authorization gate checks
+EntryType.COMMAND          // CLI command executions
+EntryType.MODEL            // ORM model lifecycle events
+EntryType.NOTIFICATION     // Notification events
+EntryType.DUMP             // Debug dump output
+```
+
+---
+
+## API Endpoints
+
+All endpoints are prefixed with your configured `path` (default: `/telescope`).
+
+| Method | Endpoint | Description |
+|---|---|---|
+| `POST` | `/api/login` | Authenticate with password, returns JWT |
+| `GET` | `/api/stats` | Get entry counts by type |
+| `GET` | `/api/entries` | Query entries with filters (`type`, `search`, `batchId`, `page`, `perPage`) |
+| `GET` | `/api/entries/:uuid` | Get a single entry by UUID |
+| `DELETE` | `/api/entries` | Clear all entries |
+
+---
+
 ## Development & Test
 
 To build the package:
@@ -145,3 +271,25 @@ To run Jest tests:
 npm run test
 ```
 
+---
+
+## Migration from v0.2.x
+
+If upgrading from v0.2.x (which used TypeORM/SQL):
+
+1. Install the new dependencies:
+   ```bash
+   npm install @ngn-net/nestjs-telescope @nestjs/mongoose mongoose
+   ```
+
+2. Add `MongooseModule.forRoot()` to your root module (if not already present).
+
+3. Remove the old TypeORM-based telescope entity — Telescope now manages its own MongoDB collection automatically.
+
+4. The old `telescope_entries` SQL table can be dropped after migration.
+
+---
+
+## License
+
+MIT

package/dist/index.js

@@ -14,7 +14,6 @@ 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);
@@ -25,7 +24,6 @@ __exportStar(require("./interfaces/entry.interface"), exports);
 __exportStar(require("./guards/telescope-jwt.guard"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./dashboard.provider"), exports);
-// Export all watchers for custom usage/extension
 __exportStar(require("./watchers/command.watcher"), exports);
 __exportStar(require("./watchers/model.watcher"), exports);
 __exportStar(require("./watchers/notification.watcher"), exports);

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

@@ -1,6 +1,8 @@
+import { Document, HydratedDocument } from 'mongoose';
 import { EntryType } from '../../enums/entry-type.enum';
+export type TelescopeEntryDocument = HydratedDocument<TelescopeEntry>;
 export declare class TelescopeEntry {
-    id: number;
+    _id?: any;
     uuid: string;
     batchId?: string;
     type: EntryType;
@@ -8,3 +10,12 @@ export declare class TelescopeEntry {
     recordedAt: Date;
     familyHash?: string;
 }
+export declare const TelescopeEntrySchema: import("mongoose").Schema<TelescopeEntry, import("mongoose").Model<TelescopeEntry, any, any, any, Document<unknown, any, TelescopeEntry, any, {}> & TelescopeEntry & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TelescopeEntry, Document<unknown, {}, import("mongoose").FlatRecord<TelescopeEntry>, {}, import("mongoose").DefaultSchemaOptions> & import("mongoose").FlatRecord<TelescopeEntry> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;

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

@@ -9,36 +9,11 @@ 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");
+exports.TelescopeEntrySchema = exports.TelescopeEntry = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
 const entry_type_enum_1 = require("../../enums/entry-type.enum");
-/**
- * Custom ValueTransformer that serializes objects to JSON strings and back.
- * This allows the `content` column to work on all databases (SQLite, MySQL, PostgreSQL)
- * by storing JSON as plain text instead of requiring a `jsonb` column type.
- */
-const JsonTransformer = {
-    to(value) {
-        if (value === null || value === undefined)
-            return '{}';
-        return typeof value === 'string' ? value : JSON.stringify(value);
-    },
-    from(value) {
-        if (value === null || value === undefined)
-            return {};
-        if (typeof value === 'object')
-            return value; // Already parsed (some drivers do this)
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return {};
-        }
-    },
-};
 let TelescopeEntry = class TelescopeEntry {
-    id;
+    _id;
     uuid;
     batchId;
     type;
@@ -48,36 +23,30 @@ let TelescopeEntry = class TelescopeEntry {
 };
 exports.TelescopeEntry = TelescopeEntry;
 __decorate([
-    (0, typeorm_1.PrimaryGeneratedColumn)(),
-    __metadata("design:type", Number)
-], TelescopeEntry.prototype, "id", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', length: 64 }),
-    (0, typeorm_1.Index)({ unique: true }),
+    (0, mongoose_1.Prop)({ type: String, required: true, unique: true, index: true }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "uuid", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', length: 64, nullable: true }),
+    (0, mongoose_1.Prop)({ type: String, index: true, default: null }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "batchId", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', length: 50 }),
+    (0, mongoose_1.Prop)({ type: String, required: true, index: true }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "type", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'text', transformer: JsonTransformer }),
+    (0, mongoose_1.Prop)({ type: Object, default: {} }),
     __metadata("design:type", Object)
 ], TelescopeEntry.prototype, "content", void 0);
 __decorate([
-    (0, typeorm_1.CreateDateColumn)(),
+    (0, mongoose_1.Prop)({ type: Date, default: () => new Date(), index: true }),
     __metadata("design:type", Date)
 ], TelescopeEntry.prototype, "recordedAt", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'varchar', length: 64, nullable: true }),
+    (0, mongoose_1.Prop)({ type: String, default: null }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "familyHash", void 0);
 exports.TelescopeEntry = TelescopeEntry = __decorate([
-    (0, typeorm_1.Entity)({ name: 'telescope_entries' }),
-    (0, typeorm_1.Index)(['type']),
-    (0, typeorm_1.Index)(['recordedAt'])
+    (0, mongoose_1.Schema)({ collection: 'telescope_entries', timestamps: false })
 ], TelescopeEntry);
+exports.TelescopeEntrySchema = mongoose_1.SchemaFactory.createForClass(TelescopeEntry);

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

@@ -1,5 +1,5 @@
-import { Repository } from 'typeorm';
-import { TelescopeEntry } from './entities/telescope-entry.entity';
+import { Model } from 'mongoose';
+import { TelescopeEntry, TelescopeEntryDocument } from './entities/telescope-entry.entity';
 import { EntryType } from '../enums/entry-type.enum';
 export interface QueryFilters {
     type?: string;
@@ -16,14 +16,14 @@ export interface PaginatedResult {
     totalPages: number;
 }
 export declare class TelescopeRepository {
-    private readonly entryRepo;
-    constructor(entryRepo: Repository<TelescopeEntry>);
+    private readonly entryModel;
+    constructor(entryModel: Model<TelescopeEntryDocument>);
     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: QueryFilters): Promise<PaginatedResult>;
     findByUuid(uuid: string): Promise<TelescopeEntry | null>;
-    clearAll(): Promise<import("typeorm").DeleteResult>;
+    clearAll(): Promise<import("mongodb").DeleteResult>;
     countByType(): Promise<Record<string, number>>;
 }

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

@@ -13,62 +13,61 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 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 mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
 const telescope_entry_entity_1 = require("./entities/telescope-entry.entity");
 let TelescopeRepository = class TelescopeRepository {
-    entryRepo;
-    constructor(entryRepo) {
-        this.entryRepo = entryRepo;
+    entryModel;
+    constructor(entryModel) {
+        this.entryModel = entryModel;
     }
     async save(entry) {
-        const ent = this.entryRepo.create(entry);
-        return await this.entryRepo.save(ent);
+        const doc = new this.entryModel(entry);
+        return await doc.save();
     }
     async findAll(limit = 100) {
-        return await this.entryRepo.find({ order: { recordedAt: 'DESC' }, take: limit });
+        return await this.entryModel.find().sort({ recordedAt: -1 }).limit(limit).lean();
     }
     async findByType(type, limit = 100) {
-        return await this.entryRepo.find({ where: { type }, order: { recordedAt: 'DESC' }, take: limit });
+        return await this.entryModel.find({ type }).sort({ recordedAt: -1 }).limit(limit).lean();
     }
     async prune(maxEntries) {
-        const count = await this.entryRepo.count();
+        const count = await this.entryModel.countDocuments();
         if (count <= maxEntries)
             return;
         const excess = count - maxEntries;
-        // Use a single query to find and delete the oldest entries
-        const oldest = await this.entryRepo.find({
-            order: { recordedAt: 'ASC' },
-            take: excess,
-            select: ['id'],
-        });
+        const oldest = await this.entryModel.find().sort({ recordedAt: 1 }).limit(excess).select('_id').lean();
         if (oldest.length > 0) {
-            const ids = oldest.map((e) => e.id);
-            await this.entryRepo.delete(ids);
+            const ids = oldest.map((e) => e._id);
+            await this.entryModel.deleteMany({ _id: { $in: ids } });
         }
     }
     async queryEntries(filters) {
         const perPage = Math.min(filters.limit || 50, 200);
         const page = Math.max(filters.page || 1, 1);
         const skip = (page - 1) * perPage;
-        const qb = this.entryRepo.createQueryBuilder('entry');
-        qb.orderBy('entry.recordedAt', 'DESC');
+        const query = {};
         if (filters.type) {
-            qb.andWhere('entry.type = :type', { type: filters.type });
+            query.type = filters.type;
         }
         if (filters.batchId) {
-            qb.andWhere('entry.batchId = :batchId', { batchId: filters.batchId });
+            query.batchId = filters.batchId;
         }
-        // For search, do in-memory filtering since LIKE on JSON text varies per DB
         if (filters.search) {
-            const searchLower = `%${filters.search.toLowerCase()}%`;
-            // Try database-level search first (works on most DBs)
-            qb.andWhere('(LOWER(entry.uuid) LIKE :search OR LOWER(entry.content) LIKE :search)', { search: searchLower });
+            const searchRegex = { $regex: filters.search, $options: 'i' };
+            query.$or = [
+                { uuid: searchRegex },
+                { type: searchRegex },
+            ];
         }
-        const total = await qb.getCount();
-        const data = await qb.skip(skip).take(perPage).getMany();
+        const total = await this.entryModel.countDocuments(query);
+        const data = await this.entryModel
+            .find(query)
+            .sort({ recordedAt: -1 })
+            .skip(skip)
+            .limit(perPage)
+            .lean();
         return {
             data,
             total,
@@ -78,24 +77,18 @@ let TelescopeRepository = class TelescopeRepository {
         };
     }
     async findByUuid(uuid) {
-        return await this.entryRepo.findOne({ where: { uuid } });
+        return await this.entryModel.findOne({ uuid }).lean();
     }
     async clearAll() {
-        return await this.entryRepo
-            .createQueryBuilder()
-            .delete()
-            .execute();
+        return await this.entryModel.deleteMany({});
     }
     async countByType() {
-        const results = await this.entryRepo
-            .createQueryBuilder('entry')
-            .select('entry.type', 'type')
-            .addSelect('COUNT(*)', 'count')
-            .groupBy('entry.type')
-            .getRawMany();
+        const results = await this.entryModel.aggregate([
+            { $group: { _id: '$type', count: { $sum: 1 } } },
+        ]);
         const counts = {};
         for (const row of results) {
-            counts[row.type] = parseInt(row.count, 10);
+            counts[row._id] = row.count;
         }
         return counts;
     }
@@ -103,6 +96,6 @@ let TelescopeRepository = class TelescopeRepository {
 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])
+    __param(0, (0, mongoose_1.InjectModel)(telescope_entry_entity_1.TelescopeEntry.name)),
+    __metadata("design:paramtypes", [mongoose_2.Model])
 ], TelescopeRepository);