@ngn-net/nestjs-telescope 0.1.6 → 0.1.7

package/README.md

@@ -23,7 +23,7 @@ All telemetry records are persisted to a database table and accessible via a mod
 
 ## Installation
 
-Install the package alongside its peer dependencies:
+Install the package:
 
 ```bash
 npm install @ngn-net/nestjs-telescope @nestjs/typeorm typeorm @nestjs/jwt @nestjs/passport passport-jwt
@@ -33,6 +33,38 @@ Ensure you have TypeORM initialized in your NestJS application.
 
 ---
 
+## Optional & Peer Dependencies
+
+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 |
+|---|---|---|
+| **Cache Watcher** | `@nestjs/cache-manager` & `cache-manager` | `EntryType.CACHE` |
+| **Queue Watcher** | `@nestjs/bullmq` & `bullmq` | `EntryType.JOB` |
+| **Event Watcher** | `@nestjs/event-emitter` | `EntryType.EVENT` |
+| **Schedule Watcher** | `@nestjs/schedule` | `EntryType.SCHEDULED_TASK` |
+| **Mail Watcher** | `nodemailer` & `@types/nodemailer` | `EntryType.MAIL` |
+| **Redis Watcher** | `ioredis` | `EntryType.REDIS` |
+
+---
+
+## Configuration Reference
+
+You can pass configuration options into `TelescopeModule.forRoot(options)`:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `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. |
+| `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']`). |
+| `uiMiddleware` | `any[]` | `[]` | Custom middleware to apply to Telescope routes. |
+
+---
+
 ## Usage
 
 Import the `TelescopeModule` in your root `AppModule`:
@@ -45,54 +77,29 @@ 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',
+      type: 'sqlite', // or postgres, mysql, etc.
+      database: 'app.db',
       autoLoadEntities: true,
-      synchronize: true, // Telescope creates telescope_entries table automatically
+      synchronize: true, // Telescope automatically registers its own entity
     }),
     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,
-      ],
+      password: 'my-secure-password',
+      maxEntries: 500,
+      ignorePaths: ['/health-check'],
     }),
   ],
 })
 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`.
+2. Open your browser and navigate to `http://localhost:3000/telescope` (or your configured path).
+3. Enter the configured password (or defaults to `password`).
 4. Monitor requests, logs, queries, and errors in real-time.
 
 ---
@@ -108,3 +115,4 @@ To run Jest tests:
 ```bash
 npm run test
 ```
+

package/dist/constants.d.ts

@@ -1,3 +1,12 @@
-export declare const TELESCOPE_PATH: string;
-export declare const TELESCOPE_JWT_SECRET: string;
-export declare const TELESCOPE_DB_CONNECTION: string;
+/** Injection token for telescope configuration options */
+export declare const TELESCOPE_OPTIONS = "TELESCOPE_OPTIONS";
+/** Default base path for the Telescope UI & API */
+export declare const DEFAULT_TELESCOPE_PATH = "telescope";
+/** Default JWT secret (should always be overridden in production) */
+export declare const DEFAULT_JWT_SECRET = "telescope-change-me";
+/** Default maximum number of entries to retain */
+export declare const DEFAULT_MAX_ENTRIES = 1000;
+/** Default password for UI authentication */
+export declare const DEFAULT_PASSWORD = "password";
+/** Minimum interval (ms) between prune operations */
+export declare const PRUNE_THROTTLE_MS = 60000;

package/dist/constants.js

@@ -1,7 +1,16 @@
 "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';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRUNE_THROTTLE_MS = exports.DEFAULT_PASSWORD = exports.DEFAULT_MAX_ENTRIES = exports.DEFAULT_JWT_SECRET = exports.DEFAULT_TELESCOPE_PATH = exports.TELESCOPE_OPTIONS = void 0;
+/** Injection token for telescope configuration options */
+exports.TELESCOPE_OPTIONS = 'TELESCOPE_OPTIONS';
+/** Default base path for the Telescope UI & API */
+exports.DEFAULT_TELESCOPE_PATH = 'telescope';
+/** Default JWT secret (should always be overridden in production) */
+exports.DEFAULT_JWT_SECRET = 'telescope-change-me';
+/** Default maximum number of entries to retain */
+exports.DEFAULT_MAX_ENTRIES = 1000;
+/** Default password for UI authentication */
+exports.DEFAULT_PASSWORD = 'password';
+/** Minimum interval (ms) between prune operations */
+exports.PRUNE_THROTTLE_MS = 60_000;

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

@@ -1,14 +1,17 @@
 import { TelescopeRepository } from '../storage/telescope-repository.service';
 import { JwtService } from '@nestjs/jwt';
+import { TelescopeOptions } from '../interfaces/telescope-options.interface';
 import { Request, Response } from 'express';
 export declare class TelescopeController {
     private readonly repo;
     private readonly jwtService;
-    constructor(repo: TelescopeRepository, jwtService: JwtService);
+    private readonly options;
+    constructor(repo: TelescopeRepository, jwtService: JwtService, options: TelescopeOptions);
     login(body: any): Promise<{
         token: string;
     }>;
-    getEntries(type?: string, search?: string, limit?: string): Promise<import("..").TelescopeEntry[]>;
+    getStats(): Promise<Record<string, number>>;
+    getEntries(type?: string, search?: string, page?: string, perPage?: string, limit?: string): Promise<import("../storage/telescope-repository.service").PaginatedResult>;
     getEntry(uuid: string): Promise<import("..").TelescopeEntry>;
     clearEntries(): Promise<{
         success: boolean;

package/dist/controllers/telescope.controller.js

@@ -24,12 +24,14 @@ const fs_1 = require("fs");
 let TelescopeController = class TelescopeController {
     repo;
     jwtService;
-    constructor(repo, jwtService) {
+    options;
+    constructor(repo, jwtService, options) {
         this.repo = repo;
         this.jwtService = jwtService;
+        this.options = options;
     }
     async login(body) {
-        const password = process.env.TELESCOPE_PASSWORD || 'password';
+        const password = this.options?.password || process.env.TELESCOPE_PASSWORD || 'password';
         if (body.password === password) {
             const payload = { username: 'telescope' };
             return {
@@ -38,9 +40,19 @@ let TelescopeController = class TelescopeController {
         }
         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 getStats() {
+        return await this.repo.countByType();
+    }
+    async getEntries(type, search, page, perPage, limit) {
+        const pageNum = page ? parseInt(page, 10) : 1;
+        const limitNum = limit ? parseInt(limit, 10) : undefined;
+        const perPageNum = perPage ? parseInt(perPage, 10) : (limitNum || 50);
+        return await this.repo.queryEntries({
+            type,
+            search,
+            page: pageNum,
+            limit: perPageNum,
+        });
     }
     async getEntry(uuid) {
         const entry = await this.repo.findByUuid(uuid);
@@ -56,9 +68,10 @@ let TelescopeController = class TelescopeController {
     // 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
+        const basePath = this.options?.path || constants_1.DEFAULT_TELESCOPE_PATH;
+        // Strip basePath 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}`), '');
+        let assetPath = rawPath.replace(new RegExp(`^/${basePath}`), '');
         if (assetPath.startsWith('/')) {
             assetPath = assetPath.substring(1);
         }
@@ -66,12 +79,17 @@ let TelescopeController = class TelescopeController {
         if (!assetPath || !assetPath.includes('.')) {
             assetPath = 'index.html';
         }
-        const filePath = (0, path_1.join)(__dirname, '../../ui', assetPath);
+        // Locate UI directory in either source (dev) or dist (prod) mode
+        let uiDir = (0, path_1.join)(__dirname, '../../ui');
+        if (!(0, fs_1.existsSync)((0, path_1.join)(uiDir, 'index.html'))) {
+            uiDir = (0, path_1.join)(__dirname, '../ui');
+        }
+        const filePath = (0, path_1.join)(uiDir, 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');
+        const fallbackPath = (0, path_1.join)(uiDir, 'index.html');
         if ((0, fs_1.existsSync)(fallbackPath)) {
             return res.sendFile(fallbackPath);
         }
@@ -86,14 +104,23 @@ __decorate([
     __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/stats'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TelescopeController.prototype, "getStats", 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')),
+    __param(2, (0, common_1.Query)('page')),
+    __param(3, (0, common_1.Query)('perPage')),
+    __param(4, (0, common_1.Query)('limit')),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:paramtypes", [String, String, String, String, String]),
     __metadata("design:returntype", Promise)
 ], TelescopeController.prototype, "getEntries", null);
 __decorate([
@@ -120,7 +147,8 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], TelescopeController.prototype, "serveStatic", null);
 exports.TelescopeController = TelescopeController = __decorate([
-    (0, common_1.Controller)(constants_1.TELESCOPE_PATH),
+    (0, common_1.Controller)(),
+    __param(2, (0, common_1.Inject)(constants_1.TELESCOPE_OPTIONS)),
     __metadata("design:paramtypes", [telescope_repository_service_1.TelescopeRepository,
-        jwt_1.JwtService])
+        jwt_1.JwtService, Object])
 ], TelescopeController);

package/dist/index.d.ts

@@ -6,3 +6,14 @@ export * from './enums/entry-type.enum';
 export * from './interfaces/telescope-options.interface';
 export * from './interfaces/entry.interface';
 export * from './guards/telescope-jwt.guard';
+export * from './constants';
+export * from './watchers/http-request.watcher';
+export * from './watchers/query.watcher';
+export * from './watchers/cache.watcher';
+export * from './watchers/queue.watcher';
+export * from './watchers/event.watcher';
+export * from './watchers/mail.watcher';
+export * from './watchers/log.watcher';
+export * from './watchers/exception.watcher';
+export * from './watchers/schedule.watcher';
+export * from './watchers/redis.watcher';

package/dist/index.js

@@ -23,3 +23,15 @@ __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);
+__exportStar(require("./constants"), exports);
+// Export all watchers for custom usage/extension
+__exportStar(require("./watchers/http-request.watcher"), exports);
+__exportStar(require("./watchers/query.watcher"), exports);
+__exportStar(require("./watchers/cache.watcher"), exports);
+__exportStar(require("./watchers/queue.watcher"), exports);
+__exportStar(require("./watchers/event.watcher"), exports);
+__exportStar(require("./watchers/mail.watcher"), exports);
+__exportStar(require("./watchers/log.watcher"), exports);
+__exportStar(require("./watchers/exception.watcher"), exports);
+__exportStar(require("./watchers/schedule.watcher"), exports);
+__exportStar(require("./watchers/redis.watcher"), exports);

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

@@ -1,13 +1,19 @@
 import { EntryType } from '../enums/entry-type.enum';
 export interface TelescopeOptions {
-    /** Base path for UI (default: /telescope) */
+    /** Base path for UI and API (default: 'telescope') */
     path?: string;
     /** JWT secret used for UI authentication */
     jwtSecret?: string;
-    /** Which entry types to enable */
+    /** Password for dashboard login (default: 'password', or env TELESCOPE_PASSWORD) */
+    password?: string;
+    /** Which entry types to enable (default: all) */
     enabledEntryTypes?: EntryType[];
-    /** Max number of entries to retain (pruning) */
+    /** Max number of entries to retain in the database (default: 1000) */
     maxEntries?: number;
+    /** Request paths to ignore (e.g., ['/health', '/telescope']) */
+    ignorePaths?: string[];
+    /** Redis commands to ignore (e.g., ['info', 'ping']) */
+    ignoreCommands?: string[];
     /** Additional middleware to apply to UI routes */
     uiMiddleware?: any[];
 }

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

@@ -13,6 +13,30 @@ 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");
+/**
+ * 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;
     uuid;
@@ -28,29 +52,32 @@ __decorate([
     __metadata("design:type", Number)
 ], TelescopeEntry.prototype, "id", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'uuid' }),
+    (0, typeorm_1.Column)({ type: 'varchar', length: 64 }),
+    (0, typeorm_1.Index)({ unique: true }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "uuid", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ nullable: true }),
+    (0, typeorm_1.Column)({ type: 'varchar', length: 64, nullable: true }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "batchId", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'enum', enum: entry_type_enum_1.EntryType }),
+    (0, typeorm_1.Column)({ type: 'varchar', length: 50 }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "type", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'jsonb' }),
+    (0, typeorm_1.Column)({ type: 'text', transformer: JsonTransformer }),
     __metadata("design:type", Object)
 ], TelescopeEntry.prototype, "content", void 0);
 __decorate([
-    (0, typeorm_1.CreateDateColumn)({ type: 'timestamp' }),
+    (0, typeorm_1.CreateDateColumn)(),
     __metadata("design:type", Date)
 ], TelescopeEntry.prototype, "recordedAt", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ nullable: true }),
+    (0, typeorm_1.Column)({ type: 'varchar', length: 64, nullable: true }),
     __metadata("design:type", String)
 ], TelescopeEntry.prototype, "familyHash", void 0);
 exports.TelescopeEntry = TelescopeEntry = __decorate([
-    (0, typeorm_1.Entity)({ name: 'telescope_entries' })
+    (0, typeorm_1.Entity)({ name: 'telescope_entries' }),
+    (0, typeorm_1.Index)(['type']),
+    (0, typeorm_1.Index)(['recordedAt'])
 ], TelescopeEntry);

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

@@ -1,6 +1,19 @@
-import { Repository, DeleteResult } from 'typeorm';
+import { Repository } from 'typeorm';
 import { TelescopeEntry } from './entities/telescope-entry.entity';
 import { EntryType } from '../enums/entry-type.enum';
+export interface QueryFilters {
+    type?: string;
+    search?: string;
+    limit?: number;
+    page?: number;
+}
+export interface PaginatedResult {
+    data: TelescopeEntry[];
+    total: number;
+    page: number;
+    perPage: number;
+    totalPages: number;
+}
 export declare class TelescopeRepository {
     private readonly entryRepo;
     constructor(entryRepo: Repository<TelescopeEntry>);
@@ -8,11 +21,8 @@ export declare class TelescopeRepository {
     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[]>;
+    queryEntries(filters: QueryFilters): Promise<PaginatedResult>;
     findByUuid(uuid: string): Promise<TelescopeEntry | null>;
-    clearAll(): Promise<DeleteResult>;
+    clearAll(): Promise<import("typeorm").DeleteResult>;
+    countByType(): Promise<Record<string, number>>;
 }

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

@@ -38,29 +38,41 @@ let TelescopeRepository = class TelescopeRepository {
         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);
+        // Use a single query to find and delete the oldest entries
+        const oldest = await this.entryRepo.find({
+            order: { recordedAt: 'ASC' },
+            take: excess,
+            select: ['id'],
+        });
+        if (oldest.length > 0) {
+            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,
-        };
+        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');
         if (filters.type) {
-            findOptions.where = { type: filters.type };
+            qb.andWhere('entry.type = :type', { type: filters.type });
         }
-        let entries = await this.entryRepo.find(findOptions);
+        // For search, do in-memory filtering since LIKE on JSON text varies per DB
         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;
-            });
+            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 });
         }
-        return entries;
+        const total = await qb.getCount();
+        const data = await qb.skip(skip).take(perPage).getMany();
+        return {
+            data,
+            total,
+            page,
+            perPage,
+            totalPages: Math.ceil(total / perPage),
+        };
     }
     async findByUuid(uuid) {
         return await this.entryRepo.findOne({ where: { uuid } });
@@ -68,6 +80,19 @@ let TelescopeRepository = class TelescopeRepository {
     async clearAll() {
         return await this.entryRepo.delete({});
     }
+    async countByType() {
+        const results = await this.entryRepo
+            .createQueryBuilder('entry')
+            .select('entry.type', 'type')
+            .addSelect('COUNT(*)', 'count')
+            .groupBy('entry.type')
+            .getRawMany();
+        const counts = {};
+        for (const row of results) {
+            counts[row.type] = parseInt(row.count, 10);
+        }
+        return counts;
+    }
 };
 exports.TelescopeRepository = TelescopeRepository;
 exports.TelescopeRepository = TelescopeRepository = __decorate([

package/dist/telescope.module.d.ts

@@ -1,4 +1,8 @@
-import { DynamicModule } from '@nestjs/common';
-export declare class TelescopeModule {
+import { DynamicModule, OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+export declare class TelescopeModule implements OnModuleInit {
+    private readonly moduleRef;
+    constructor(moduleRef: ModuleRef);
+    onModuleInit(): void;
     static forRoot(options?: any): DynamicModule;
 }