nest-devtools 0.1.0

package/dist/dashboard/index.html.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.html.js","sourceRoot":"","sources":["../../src/dashboard/index.html.ts"],"names":[],"mappings":";;AAohCA,kDAOC;AA3hCD,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkhCnB,CAAC;AAET,SAAgB,mBAAmB,CAAC,QAAgB;IAClD,OAAO,kBAAkB,CAAC,OAAO,CAC/B,0BAA0B,EAC1B,IAAI,CAAC,SAAS,CAAC;QACb,QAAQ;KACT,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/devtools.controller.d.ts

@@ -0,0 +1,2 @@
+import { Type } from '@nestjs/common';
+export declare function createDevtoolsController(controllerPath: string): Type;

package/dist/devtools.controller.js

@@ -0,0 +1,87 @@
+"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.createDevtoolsController = createDevtoolsController;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const index_html_1 = require("./dashboard/index.html");
+const devtools_realtime_1 = require("./devtools.realtime");
+const devtools_store_1 = require("./devtools.store");
+function createDevtoolsController(controllerPath) {
+    let DevtoolsControllerHost = class DevtoolsControllerHost {
+        constructor(store, realtimeServer, options) {
+            this.store = store;
+            this.realtimeServer = realtimeServer;
+            this.options = options;
+        }
+        dashboard() {
+            return (0, index_html_1.renderDashboardHtml)(this.options.absolutePath);
+        }
+        getLogs() {
+            return this.store.getLogs();
+        }
+        getRequests() {
+            return this.store.getRequests();
+        }
+        clearLogs() {
+            this.store.clear('logs');
+            this.realtimeServer.broadcastClear('logs');
+        }
+        clearRequests() {
+            this.store.clear('requests');
+            this.realtimeServer.broadcastClear('requests');
+        }
+    };
+    __decorate([
+        (0, common_1.Get)(),
+        (0, common_1.Header)('content-type', 'text/html; charset=utf-8'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", String)
+    ], DevtoolsControllerHost.prototype, "dashboard", null);
+    __decorate([
+        (0, common_1.Get)('api/logs'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], DevtoolsControllerHost.prototype, "getLogs", null);
+    __decorate([
+        (0, common_1.Get)('api/requests'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], DevtoolsControllerHost.prototype, "getRequests", null);
+    __decorate([
+        (0, common_1.Delete)('api/logs'),
+        (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], DevtoolsControllerHost.prototype, "clearLogs", null);
+    __decorate([
+        (0, common_1.Delete)('api/requests'),
+        (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", []),
+        __metadata("design:returntype", void 0)
+    ], DevtoolsControllerHost.prototype, "clearRequests", null);
+    DevtoolsControllerHost = __decorate([
+        (0, common_1.Controller)(controllerPath),
+        __param(2, (0, common_1.Inject)(constants_1.DEVTOOLS_OPTIONS)),
+        __metadata("design:paramtypes", [devtools_store_1.DevtoolsStore,
+            devtools_realtime_1.DevtoolsRealtimeServer, Object])
+    ], DevtoolsControllerHost);
+    return DevtoolsControllerHost;
+}
+//# sourceMappingURL=devtools.controller.js.map

package/dist/devtools.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.controller.js","sourceRoot":"","sources":["../src/devtools.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAQA,4DAyCC;AAjDD,2CAAqG;AAErG,2CAA+C;AAC/C,uDAA6D;AAC7D,2DAA6D;AAC7D,qDAAiD;AAGjD,SAAgB,wBAAwB,CAAC,cAAsB;IAC7D,IACM,sBAAsB,GAD5B,MACM,sBAAsB;QAC1B,YACmB,KAAoB,EACpB,cAAsC,EACZ,OAAgC;YAF1D,UAAK,GAAL,KAAK,CAAe;YACpB,mBAAc,GAAd,cAAc,CAAwB;YACZ,YAAO,GAAP,OAAO,CAAyB;QAC1E,CAAC;QAIJ,SAAS;YACP,OAAO,IAAA,gCAAmB,EAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACxD,CAAC;QAGD,OAAO;YACL,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QAC9B,CAAC;QAGD,WAAW;YACT,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAClC,CAAC;QAID,SAAS;YACP,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;QAID,aAAa;YACX,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC7B,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACjD,CAAC;KACF,CAAA;IA3BC;QAFC,IAAA,YAAG,GAAE;QACL,IAAA,eAAM,EAAC,cAAc,EAAE,0BAA0B,CAAC;;;;2DAGlD;IAGD;QADC,IAAA,YAAG,EAAC,UAAU,CAAC;;;;yDAGf;IAGD;QADC,IAAA,YAAG,EAAC,cAAc,CAAC;;;;6DAGnB;IAID;QAFC,IAAA,eAAM,EAAC,UAAU,CAAC;QAClB,IAAA,iBAAQ,EAAC,mBAAU,CAAC,UAAU,CAAC;;;;2DAI/B;IAID;QAFC,IAAA,eAAM,EAAC,cAAc,CAAC;QACtB,IAAA,iBAAQ,EAAC,mBAAU,CAAC,UAAU,CAAC;;;;+DAI/B;IAnCG,sBAAsB;QAD3B,IAAA,mBAAU,EAAC,cAAc,CAAC;QAKtB,WAAA,IAAA,eAAM,EAAC,4BAAgB,CAAC,CAAA;yCAFD,8BAAa;YACJ,0CAAsB;OAHrD,sBAAsB,CAoC3B;IAED,OAAO,sBAAsB,CAAC;AAChC,CAAC"}

package/dist/devtools.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+import { DevtoolsOptions } from './types';
+export declare class DevtoolsModule {
+    static forRoot(options?: DevtoolsOptions): DynamicModule;
+    private static createProviders;
+}

package/dist/devtools.module.js

@@ -0,0 +1,55 @@
+"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 DevtoolsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevtoolsModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("./constants");
+const devtools_controller_1 = require("./devtools.controller");
+const devtools_realtime_1 = require("./devtools.realtime");
+const devtools_store_1 = require("./devtools.store");
+const logger_capture_1 = require("./logger/logger.capture");
+const request_interceptor_1 = require("./request/request.interceptor");
+const path_1 = require("./utils/path");
+let DevtoolsModule = DevtoolsModule_1 = class DevtoolsModule {
+    static forRoot(options) {
+        if (process.env.NODE_ENV === 'production') {
+            return {
+                module: DevtoolsModule_1,
+            };
+        }
+        const resolvedOptions = (0, path_1.normalizeDevtoolsOptions)(options);
+        const controller = (0, devtools_controller_1.createDevtoolsController)(resolvedOptions.controllerPath);
+        return {
+            module: DevtoolsModule_1,
+            controllers: [controller],
+            providers: this.createProviders(resolvedOptions),
+        };
+    }
+    static createProviders(options) {
+        return [
+            {
+                provide: constants_1.DEVTOOLS_OPTIONS,
+                useValue: options,
+            },
+            devtools_store_1.DevtoolsStore,
+            devtools_realtime_1.DevtoolsRealtimeServer,
+            logger_capture_1.DevtoolsLoggerCapture,
+            {
+                provide: core_1.APP_INTERCEPTOR,
+                useClass: request_interceptor_1.RequestInterceptor,
+            },
+        ];
+    }
+};
+exports.DevtoolsModule = DevtoolsModule;
+exports.DevtoolsModule = DevtoolsModule = DevtoolsModule_1 = __decorate([
+    (0, common_1.Module)({})
+], DevtoolsModule);
+//# sourceMappingURL=devtools.module.js.map

package/dist/devtools.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.module.js","sourceRoot":"","sources":["../src/devtools.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAiE;AACjE,uCAA+C;AAE/C,2CAA+C;AAC/C,+DAAiE;AACjE,2DAA6D;AAC7D,qDAAiD;AACjD,4DAAgE;AAChE,uEAAmE;AAEnE,uCAAwD;AAGjD,IAAM,cAAc,sBAApB,MAAM,cAAc;IACzB,MAAM,CAAC,OAAO,CAAC,OAAyB;QACtC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE,CAAC;YAC1C,OAAO;gBACL,MAAM,EAAE,gBAAc;aACvB,CAAC;QACJ,CAAC;QAED,MAAM,eAAe,GAAG,IAAA,+BAAwB,EAAC,OAAO,CAAC,CAAC;QAC1D,MAAM,UAAU,GAAG,IAAA,8CAAwB,EAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QAE5E,OAAO;YACL,MAAM,EAAE,gBAAc;YACtB,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC;SACjD,CAAC;IACJ,CAAC;IAEO,MAAM,CAAC,eAAe,CAAC,OAAgC;QAC7D,OAAO;YACL;gBACE,OAAO,EAAE,4BAAgB;gBACzB,QAAQ,EAAE,OAAO;aAClB;YACD,8BAAa;YACb,0CAAsB;YACtB,sCAAqB;YACrB;gBACE,OAAO,EAAE,sBAAe;gBACxB,QAAQ,EAAE,wCAAkB;aAC7B;SACF,CAAC;IACJ,CAAC;CACF,CAAA;AAjCY,wCAAc;yBAAd,cAAc;IAD1B,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,cAAc,CAiC1B"}

package/dist/devtools.realtime.d.ts

@@ -0,0 +1,18 @@
+import { OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { LogEntry, RequestEntry, ResolvedDevtoolsOptions } from './types';
+export declare class DevtoolsRealtimeServer implements OnApplicationBootstrap, OnModuleDestroy {
+    private readonly adapterHost;
+    private readonly options;
+    private readonly clients;
+    private httpServer?;
+    private boundUpgradeHandler?;
+    constructor(adapterHost: HttpAdapterHost, options: ResolvedDevtoolsOptions);
+    onApplicationBootstrap(): void;
+    onModuleDestroy(): void;
+    broadcastLog(entry: LogEntry): void;
+    broadcastRequest(entry: RequestEntry): void;
+    broadcastClear(kind: 'logs' | 'requests'): void;
+    private handleUpgrade;
+    private broadcast;
+}

package/dist/devtools.realtime.js

@@ -0,0 +1,111 @@
+"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.DevtoolsRealtimeServer = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("./constants");
+const websocket_utils_1 = require("./realtime/websocket.utils");
+let DevtoolsRealtimeServer = class DevtoolsRealtimeServer {
+    constructor(adapterHost, options) {
+        this.adapterHost = adapterHost;
+        this.options = options;
+        this.clients = new Set();
+    }
+    onApplicationBootstrap() {
+        const server = this.adapterHost.httpAdapter?.getHttpServer?.();
+        if (!server || typeof server.on !== 'function') {
+            return;
+        }
+        this.httpServer = server;
+        this.boundUpgradeHandler = this.handleUpgrade.bind(this);
+        server.on('upgrade', this.boundUpgradeHandler);
+    }
+    onModuleDestroy() {
+        if (this.httpServer && this.boundUpgradeHandler) {
+            this.httpServer.off('upgrade', this.boundUpgradeHandler);
+        }
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+    }
+    broadcastLog(entry) {
+        this.broadcast({ type: 'log', payload: entry });
+    }
+    broadcastRequest(entry) {
+        this.broadcast({ type: 'request', payload: entry });
+    }
+    broadcastClear(kind) {
+        this.broadcast(kind === 'logs' ? { type: 'clear:logs' } : { type: 'clear:requests' });
+    }
+    handleUpgrade(request, socket, head) {
+        const requestUrl = new URL(request.url ?? '/', 'http://127.0.0.1');
+        if (requestUrl.pathname !== this.options.websocketPath) {
+            return;
+        }
+        const key = request.headers['sec-websocket-key'];
+        const version = request.headers['sec-websocket-version'];
+        if (request.method !== 'GET' || typeof key !== 'string' || version !== '13') {
+            socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        if (head.length > 0) {
+            socket.unshift(head);
+        }
+        const acceptValue = (0, websocket_utils_1.createWebSocketAcceptValue)(key);
+        socket.write([
+            'HTTP/1.1 101 Switching Protocols',
+            'Upgrade: websocket',
+            'Connection: Upgrade',
+            `Sec-WebSocket-Accept: ${acceptValue}`,
+            '\r\n',
+        ].join('\r\n'));
+        const cleanup = () => {
+            this.clients.delete(socket);
+        };
+        socket.on('close', cleanup);
+        socket.on('end', cleanup);
+        socket.on('error', cleanup);
+        socket.setNoDelay(true);
+        this.clients.add(socket);
+    }
+    broadcast(message) {
+        if (this.clients.size === 0) {
+            return;
+        }
+        const frame = (0, websocket_utils_1.encodeWebSocketTextFrame)(JSON.stringify(message));
+        for (const client of [...this.clients]) {
+            if (client.destroyed) {
+                this.clients.delete(client);
+                continue;
+            }
+            try {
+                client.write(frame);
+            }
+            catch {
+                client.destroy();
+                this.clients.delete(client);
+            }
+        }
+    }
+};
+exports.DevtoolsRealtimeServer = DevtoolsRealtimeServer;
+exports.DevtoolsRealtimeServer = DevtoolsRealtimeServer = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.DEVTOOLS_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.HttpAdapterHost, Object])
+], DevtoolsRealtimeServer);
+//# sourceMappingURL=devtools.realtime.js.map

package/dist/devtools.realtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.realtime.js","sourceRoot":"","sources":["../src/devtools.realtime.ts"],"names":[],"mappings":"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"}

package/dist/devtools.store.d.ts

@@ -0,0 +1,12 @@
+import { ResolvedDevtoolsOptions, LogEntry, RequestEntry } from './types';
+export declare class DevtoolsStore {
+    private readonly options;
+    private readonly logs;
+    private readonly requests;
+    constructor(options: ResolvedDevtoolsOptions);
+    addLog(entry: LogEntry): void;
+    addRequest(entry: RequestEntry): void;
+    getLogs(): LogEntry[];
+    getRequests(): RequestEntry[];
+    clear(type: 'logs' | 'requests'): void;
+}

package/dist/devtools.store.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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevtoolsStore = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("./constants");
+const ring_buffer_1 = require("./utils/ring-buffer");
+let DevtoolsStore = class DevtoolsStore {
+    constructor(options) {
+        this.options = options;
+        this.logs = new ring_buffer_1.RingBuffer(options.maxLogs);
+        this.requests = new ring_buffer_1.RingBuffer(options.maxRequests);
+    }
+    addLog(entry) {
+        this.logs.push(entry);
+    }
+    addRequest(entry) {
+        this.requests.push(entry);
+    }
+    getLogs() {
+        return this.logs.values();
+    }
+    getRequests() {
+        return this.requests.values();
+    }
+    clear(type) {
+        if (type === 'logs') {
+            this.logs.clear();
+            return;
+        }
+        this.requests.clear();
+    }
+};
+exports.DevtoolsStore = DevtoolsStore;
+exports.DevtoolsStore = DevtoolsStore = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(constants_1.DEVTOOLS_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], DevtoolsStore);
+//# sourceMappingURL=devtools.store.js.map

package/dist/devtools.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devtools.store.js","sourceRoot":"","sources":["../src/devtools.store.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAAoD;AAEpD,2CAA+C;AAE/C,qDAAiD;AAG1C,IAAM,aAAa,GAAnB,MAAM,aAAa;IAIxB,YAC6C,OAAgC;QAAhC,YAAO,GAAP,OAAO,CAAyB;QAE3E,IAAI,CAAC,IAAI,GAAG,IAAI,wBAAU,CAAW,OAAO,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAU,CAAe,OAAO,CAAC,WAAW,CAAC,CAAC;IACpE,CAAC;IAED,MAAM,CAAC,KAAe;QACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED,UAAU,CAAC,KAAmB;QAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,IAAyB;QAC7B,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;CACF,CAAA;AAnCY,sCAAa;wBAAb,aAAa;IADzB,IAAA,mBAAU,GAAE;IAMR,WAAA,IAAA,eAAM,EAAC,4BAAgB,CAAC,CAAA;;GALhB,aAAa,CAmCzB"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { DevtoolsModule } from './devtools.module';
+export type { DevtoolsOptions, DevtoolsRealtimeMessage, LogEntry, RequestEntry, } from './types';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevtoolsModule = void 0;
+var devtools_module_1 = require("./devtools.module");
+Object.defineProperty(exports, "DevtoolsModule", { enumerable: true, get: function () { return devtools_module_1.DevtoolsModule; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAAmD;AAA1C,iHAAA,cAAc,OAAA"}

package/dist/logger/logger.capture.d.ts

@@ -0,0 +1,23 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { DevtoolsRealtimeServer } from '../devtools.realtime';
+import { DevtoolsStore } from '../devtools.store';
+import { LogLevel } from '../types';
+export interface CapturedLogPayload {
+    level: LogLevel;
+    context: string;
+    message: string;
+}
+type LoggerListener = (payload: CapturedLogPayload) => void;
+type LoggerMethod = 'log' | 'warn' | 'error' | 'debug' | 'verbose';
+export declare function createCapturedLogPayload(level: LoggerMethod, logger: unknown, args: unknown[]): CapturedLogPayload;
+export declare function registerLoggerListener(listener: LoggerListener): () => void;
+export declare function resetLoggerPatchStateForTests(): void;
+export declare class DevtoolsLoggerCapture implements OnModuleInit, OnModuleDestroy {
+    private readonly store;
+    private readonly realtimeServer;
+    private unregister?;
+    constructor(store: DevtoolsStore, realtimeServer: DevtoolsRealtimeServer);
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+}
+export {};

package/dist/logger/logger.capture.js

@@ -0,0 +1,246 @@
+"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.DevtoolsLoggerCapture = void 0;
+exports.createCapturedLogPayload = createCapturedLogPayload;
+exports.registerLoggerListener = registerLoggerListener;
+exports.resetLoggerPatchStateForTests = resetLoggerPatchStateForTests;
+const common_1 = require("@nestjs/common");
+const util_1 = require("util");
+const devtools_realtime_1 = require("../devtools.realtime");
+const devtools_store_1 = require("../devtools.store");
+const id_1 = require("../utils/id");
+const LOGGER_PATCH_STATE = Symbol.for('nest-devtools.logger-patch-state');
+function getLoggerPatchState() {
+    const globalState = globalThis;
+    if (!globalState[LOGGER_PATCH_STATE]) {
+        globalState[LOGGER_PATCH_STATE] = {
+            listeners: new Set(),
+            originals: {
+                console: {
+                    log: common_1.ConsoleLogger.prototype.log,
+                    warn: common_1.ConsoleLogger.prototype.warn,
+                    error: common_1.ConsoleLogger.prototype.error,
+                    debug: common_1.ConsoleLogger.prototype.debug,
+                    verbose: common_1.ConsoleLogger.prototype.verbose,
+                },
+                loggerInstance: {
+                    log: common_1.Logger.prototype.log,
+                    warn: common_1.Logger.prototype.warn,
+                    error: common_1.Logger.prototype.error,
+                    debug: common_1.Logger.prototype.debug,
+                    verbose: common_1.Logger.prototype.verbose,
+                },
+                loggerStatic: {
+                    log: common_1.Logger.log,
+                    warn: common_1.Logger.warn,
+                    error: common_1.Logger.error,
+                    debug: common_1.Logger.debug,
+                    verbose: common_1.Logger.verbose,
+                },
+            },
+            patched: false,
+            suppressionDepth: 0,
+        };
+    }
+    return globalState[LOGGER_PATCH_STATE];
+}
+function getLoggerContext(logger) {
+    const context = logger?.context;
+    return typeof context === 'string' ? context : '';
+}
+function formatLogValue(value) {
+    if (value instanceof Error) {
+        return value.stack ?? value.message;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return (0, util_1.inspect)(value, {
+        depth: 5,
+        breakLength: 120,
+        compact: true,
+    });
+}
+function looksLikeStackTrace(value) {
+    return value.includes('\n') || value.includes(' at ') || value.startsWith('Error:');
+}
+function resolveStandardPayload(level, logger, args) {
+    const values = [...args];
+    let context = getLoggerContext(logger);
+    if (!context && values.length > 1 && typeof values[values.length - 1] === 'string') {
+        context = String(values.pop());
+    }
+    return {
+        level,
+        context,
+        message: values.map((value) => formatLogValue(value)).join(' ').trim(),
+    };
+}
+function resolveErrorPayload(logger, args) {
+    const [message, second, third, ...rest] = args;
+    let context = getLoggerContext(logger);
+    let stack;
+    if (typeof third === 'string') {
+        context = third;
+    }
+    if (second !== undefined) {
+        if (!context && typeof second === 'string' && !looksLikeStackTrace(second) && third === undefined) {
+            context = second;
+        }
+        else {
+            stack = formatLogValue(second);
+        }
+    }
+    if (rest.length > 0) {
+        const restText = rest.map((value) => formatLogValue(value)).join('\n').trim();
+        stack = [stack, restText].filter(Boolean).join('\n');
+    }
+    return {
+        level: 'error',
+        context,
+        message: [formatLogValue(message), stack].filter(Boolean).join('\n').trim(),
+    };
+}
+function createCapturedLogPayload(level, logger, args) {
+    if (level === 'error') {
+        return resolveErrorPayload(logger, args);
+    }
+    return resolveStandardPayload(level, logger, args);
+}
+function notifyListeners(payload) {
+    const state = getLoggerPatchState();
+    for (const listener of state.listeners) {
+        try {
+            listener(payload);
+        }
+        catch {
+            // Ignore listener failures so logging continues to behave normally.
+        }
+    }
+}
+function patchLoggerMethods() {
+    const state = getLoggerPatchState();
+    if (state.patched) {
+        return;
+    }
+    const methods = ['log', 'warn', 'error', 'debug', 'verbose'];
+    for (const method of methods) {
+        common_1.ConsoleLogger.prototype[method] = function patchedConsoleLoggerMethod(...args) {
+            const payload = createCapturedLogPayload(method, this, args);
+            const original = state.originals.console[method];
+            const result = original.apply(this, args);
+            if (state.suppressionDepth === 0) {
+                notifyListeners(payload);
+            }
+            return result;
+        };
+        common_1.Logger.prototype[method] = function patchedNestLoggerMethod(...args) {
+            const payload = createCapturedLogPayload(method, this, args);
+            const original = state.originals.loggerInstance[method];
+            let result;
+            state.suppressionDepth += 1;
+            try {
+                result = original.apply(this, args);
+            }
+            finally {
+                state.suppressionDepth -= 1;
+            }
+            notifyListeners(payload);
+            return result;
+        };
+        common_1.Logger[method] = function patchedNestLoggerStaticMethod(...args) {
+            const payload = createCapturedLogPayload(method, { context: '' }, args);
+            const original = state.originals.loggerStatic[method];
+            let result;
+            state.suppressionDepth += 1;
+            try {
+                result = original.apply(this, args);
+            }
+            finally {
+                state.suppressionDepth -= 1;
+            }
+            notifyListeners(payload);
+            return result;
+        };
+    }
+    state.patched = true;
+}
+function restoreLoggerMethodsIfUnused() {
+    const state = getLoggerPatchState();
+    if (state.listeners.size > 0 || !state.patched) {
+        return;
+    }
+    common_1.ConsoleLogger.prototype.log = state.originals.console.log;
+    common_1.ConsoleLogger.prototype.warn = state.originals.console.warn;
+    common_1.ConsoleLogger.prototype.error = state.originals.console.error;
+    common_1.ConsoleLogger.prototype.debug = state.originals.console.debug;
+    common_1.ConsoleLogger.prototype.verbose = state.originals.console.verbose;
+    common_1.Logger.prototype.log = state.originals.loggerInstance.log;
+    common_1.Logger.prototype.warn = state.originals.loggerInstance.warn;
+    common_1.Logger.prototype.error = state.originals.loggerInstance.error;
+    common_1.Logger.prototype.debug = state.originals.loggerInstance.debug;
+    common_1.Logger.prototype.verbose = state.originals.loggerInstance.verbose;
+    common_1.Logger.log = state.originals.loggerStatic.log;
+    common_1.Logger.warn = state.originals.loggerStatic.warn;
+    common_1.Logger.error = state.originals.loggerStatic.error;
+    common_1.Logger.debug = state.originals.loggerStatic.debug;
+    common_1.Logger.verbose = state.originals.loggerStatic.verbose;
+    state.patched = false;
+    state.suppressionDepth = 0;
+}
+function registerLoggerListener(listener) {
+    const state = getLoggerPatchState();
+    patchLoggerMethods();
+    state.listeners.add(listener);
+    return () => {
+        state.listeners.delete(listener);
+        restoreLoggerMethodsIfUnused();
+    };
+}
+function resetLoggerPatchStateForTests() {
+    const state = getLoggerPatchState();
+    state.listeners.clear();
+    restoreLoggerMethodsIfUnused();
+}
+let DevtoolsLoggerCapture = class DevtoolsLoggerCapture {
+    constructor(store, realtimeServer) {
+        this.store = store;
+        this.realtimeServer = realtimeServer;
+    }
+    onModuleInit() {
+        if (this.unregister) {
+            return;
+        }
+        this.unregister = registerLoggerListener((payload) => {
+            const entry = {
+                id: (0, id_1.createEntryId)('log'),
+                timestamp: new Date().toISOString(),
+                level: payload.level,
+                context: payload.context,
+                message: payload.message,
+            };
+            this.store.addLog(entry);
+            this.realtimeServer.broadcastLog(entry);
+        });
+    }
+    onModuleDestroy() {
+        this.unregister?.();
+        this.unregister = undefined;
+    }
+};
+exports.DevtoolsLoggerCapture = DevtoolsLoggerCapture;
+exports.DevtoolsLoggerCapture = DevtoolsLoggerCapture = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [devtools_store_1.DevtoolsStore,
+        devtools_realtime_1.DevtoolsRealtimeServer])
+], DevtoolsLoggerCapture);
+//# sourceMappingURL=logger.capture.js.map