server-devtools 0.1.0

package/dist/src/dashboard/dashboard-server.js

@@ -0,0 +1,676 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = __importDefault(require("../config"));
+const execution_tree_builder_1 = __importDefault(require("../core/execution-tree-builder"));
+const dashboard_errors_mapper_1 = __importDefault(require("./dashboard-errors-mapper"));
+const dashboard_request_detail_mapper_1 = __importDefault(require("./dashboard-request-detail-mapper"));
+const dashboard_response_detail_mapper_1 = __importDefault(require("./dashboard-response-detail-mapper"));
+const logger_1 = require("../utils/logger");
+const sourceBuildDashboardDirectory = node_path_1.default.resolve(__dirname, "../../dist/dashboard");
+const dashboardDirectory = (0, node_fs_1.existsSync)(node_path_1.default.join(sourceBuildDashboardDirectory, "index.html"))
+    ? sourceBuildDashboardDirectory
+    : node_path_1.default.resolve(__dirname, "../../dashboard");
+const contentTypes = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".woff2": "font/woff2",
+    ".json": "application/json; charset=utf-8",
+};
+class DashboardServer {
+    storage;
+    authService;
+    executionTreeBuilder = new execution_tree_builder_1.default();
+    requestDetailMapper = new dashboard_request_detail_mapper_1.default();
+    responseDetailMapper = new dashboard_response_detail_mapper_1.default();
+    errorMapper = new dashboard_errors_mapper_1.default();
+    // private server?: Server;
+    constructor(storage, authService) {
+        this.storage = storage;
+        this.authService = authService;
+    }
+    readJsonBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = "";
+            req.on("data", (chunk) => {
+                body += chunk.toString();
+            });
+            req.on("end", () => {
+                try {
+                    resolve(body ? JSON.parse(body) : {});
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            req.on("error", reject);
+        });
+    }
+    getCookie(req, name) {
+        const cookieHeader = req.headers.cookie;
+        if (!cookieHeader)
+            return undefined;
+        const cookies = cookieHeader.split(";");
+        for (const cookie of cookies) {
+            const [key, ...valueParts] = cookie.trim().split("=");
+            if (key === name) {
+                return decodeURIComponent(valueParts.join("="));
+            }
+        }
+        return undefined;
+    }
+    authenticateRequest(req, res) {
+        const token = this.getCookie(req, "sdt_session");
+        if (!token) {
+            this.sendUnauthorized(res);
+            return undefined;
+        }
+        const session = this.authService.getSession(token);
+        if (!session) {
+            this.sendUnauthorized(res);
+            return undefined;
+        }
+        return session;
+    }
+    sendUnauthorized(res) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(JSON.stringify({
+            message: "Unauthorized",
+        }));
+        return;
+    }
+    async handleLogin(req, res) {
+        const body = await this.readJsonBody(req);
+        const username = body?.username || null;
+        const password = body?.password || null;
+        if (!username || !password) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Password and Username are required!",
+            }));
+            return;
+        }
+        const valid = this.authService.validateCredentials(username, password);
+        if (!valid) {
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Invalid Auth Credentials",
+            }));
+            return;
+        }
+        let token;
+        try {
+            token = this.authService.createSession(username);
+        }
+        catch (error) {
+            (0, logger_1.debugLog)("Session creation failed", {
+                errorName: error instanceof Error ? error.name : typeof error,
+            });
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ message: "Unable to create session" }));
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Set-Cookie", `sdt_session=${token}; HttpOnly; SameSite=Strict; Path=/_devtools`);
+        res.setHeader("Cache-Control", "no-store");
+        res.end(JSON.stringify({
+            username,
+        }));
+        return;
+    }
+    handleLogout(req, res) {
+        const token = this.getCookie(req, "sdt_session");
+        if (token) {
+            this.authService.deleteSession(token);
+        }
+        res.setHeader("Set-Cookie", "sdt_session=; HttpOnly; SameSite=Strict; Path=/_devtools; Max-Age=0");
+        res.setHeader("Cache-Control", "no-store");
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({
+            message: "Logout Successfully!",
+        }));
+    }
+    handleProfile(req, res) {
+        const token = this.getCookie(req, "sdt_session");
+        if (!token) {
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Unauthorized",
+            }));
+            return;
+        }
+        const session = this.authService.getSession(token);
+        if (!session) {
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Unauthorized",
+            }));
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(JSON.stringify({
+            username: session.username,
+        }));
+    }
+    handle(req, res) {
+        const requestUrl = req.url ?? '';
+        const pathname = requestUrl.split('?')[0];
+        if (req.method === "POST" &&
+            pathname === `${config_1.default.DASHBOARD_API_ROUTES.AUTH}/login`) {
+            return this.handleLogin(req, res);
+        }
+        // Everything under /_devtools/api from here requires auth
+        if (pathname.startsWith("/_devtools/api/")) {
+            const session = this.authenticateRequest(req, res);
+            if (!session) {
+                return;
+            }
+        }
+        if (req.method === "POST" &&
+            pathname === `${config_1.default.DASHBOARD_API_ROUTES.AUTH}/logout`) {
+            return this.handleLogout(req, res);
+        }
+        if (req.method === "GET" &&
+            pathname === `${config_1.default.DASHBOARD_API_ROUTES.AUTH}/profile`) {
+            return this.handleProfile(req, res);
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.DELETE &&
+            pathname === config_1.default.DASHBOARD_API_ROUTES.TRACES) {
+            try {
+                this.storage.clearHistory();
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("History clear failed", {
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to clear history" }));
+                return;
+            }
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Cleared history successfully!",
+            }));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.DELETE &&
+            pathname.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`)) {
+            const traceId = decodeURIComponent(pathname.slice(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`.length));
+            let traceExists;
+            try {
+                traceExists = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!traceExists) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            try {
+                this.storage.deleteTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace deletion failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to delete trace" }));
+                return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                message: "Deleted successfully!",
+            }));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            req.url?.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`) &&
+            req.url.endsWith("/execution")) {
+            const prefix = `${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`;
+            const traceId = req.url
+                .slice(prefix.length)
+                .replace(/\/execution$/, "");
+            let trace;
+            try {
+                trace = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!trace) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            const executionTree = this.executionTreeBuilder.build(trace);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(executionTree));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            req.url?.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`) &&
+            req.url.endsWith("/request")) {
+            const prefix = `${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`;
+            const traceId = req.url
+                .slice(prefix.length)
+                .replace(/\/request$/, "");
+            let trace;
+            try {
+                trace = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!trace) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            let metadata;
+            try {
+                metadata = this.storage.getTraceMetadata(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace metadata lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace metadata" }));
+                return;
+            }
+            const request = this.requestDetailMapper.map(trace, metadata);
+            const user = metadata?.user;
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ ...request, user }));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            req.url?.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`) &&
+            req.url.endsWith("/response")) {
+            const prefix = `${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`;
+            const traceId = req.url
+                .slice(prefix.length)
+                .replace(/\/response$/, "");
+            let trace;
+            try {
+                trace = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!trace) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            let metadata;
+            try {
+                metadata = this.storage.getTraceMetadata(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace metadata lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace metadata" }));
+                return;
+            }
+            const response = this.responseDetailMapper.map(trace, metadata);
+            const user = metadata?.user;
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ ...response, user }));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            req.url?.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`) &&
+            req.url.endsWith("/errors")) {
+            const prefix = `${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`;
+            const traceId = req.url
+                .slice(prefix.length)
+                .replace(/\/errors$/, "");
+            let trace;
+            try {
+                trace = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!trace) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            const errors = this.errorMapper.map(trace);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(errors));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            pathname.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`)) {
+            const prefix = `${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`;
+            const segments = pathname.slice(prefix.length).split("/");
+            if (segments[1] === "http-client") {
+                let traceId;
+                let spanId;
+                if (segments.length !== 3) {
+                    res.statusCode = 400;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Trace and span identifiers are required",
+                    }));
+                    return;
+                }
+                try {
+                    traceId = decodeURIComponent(segments[0]);
+                    spanId = decodeURIComponent(segments[2]);
+                }
+                catch {
+                    res.statusCode = 400;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Invalid trace or span identifier",
+                    }));
+                    return;
+                }
+                if (!traceId || !spanId) {
+                    res.statusCode = 400;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Trace and span identifiers are required",
+                    }));
+                    return;
+                }
+                let trace;
+                try {
+                    trace = this.storage.getTrace(traceId);
+                }
+                catch (error) {
+                    (0, logger_1.debugLog)("Trace lookup failed", {
+                        traceId,
+                        errorName: error instanceof Error ? error.name : typeof error,
+                    });
+                    res.statusCode = 500;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ message: "Unable to read trace" }));
+                    return;
+                }
+                if (!trace) {
+                    res.statusCode = 404;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Trace not found",
+                    }));
+                    return;
+                }
+                const span = trace.spans.find(candidate => candidate.spanId === spanId);
+                if (!span) {
+                    res.statusCode = 404;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Span not found",
+                    }));
+                    return;
+                }
+                if (span.type !== "http.client") {
+                    res.statusCode = 400;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({
+                        message: "Span is not an HTTP client span",
+                    }));
+                    return;
+                }
+                let details;
+                try {
+                    details = this.storage.getHttpClientDetails(spanId);
+                }
+                catch (error) {
+                    (0, logger_1.debugLog)("HTTP client details lookup failed", {
+                        spanId,
+                        errorName: error instanceof Error ? error.name : typeof error,
+                    });
+                    res.statusCode = 500;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ message: "Unable to read HTTP client details" }));
+                    return;
+                }
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    span,
+                    ...(details ? { details } : {}),
+                }));
+                return;
+            }
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            pathname.startsWith(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`)) {
+            const traceId = decodeURIComponent(pathname.slice(`${config_1.default.DASHBOARD_API_ROUTES.TRACES}/`.length));
+            let trace;
+            try {
+                trace = this.storage.getTrace(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace" }));
+                return;
+            }
+            if (!trace) {
+                res.statusCode = 404;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Trace not found",
+                }));
+                return;
+            }
+            let metadata;
+            try {
+                metadata = this.storage.getTraceMetadata(traceId);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace metadata lookup failed", {
+                    traceId,
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace metadata" }));
+                return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ ...trace, user: metadata?.user }));
+            return;
+        }
+        if (req.method === config_1.default.REQUEST_METHOD.GET &&
+            pathname === config_1.default.DASHBOARD_API_ROUTES.REQUESTS) {
+            const searchParams = new URL(requestUrl, "http://localhost").searchParams;
+            const parsePositiveInteger = (name, fallback) => {
+                const value = searchParams.get(name);
+                if (value === null) {
+                    return fallback;
+                }
+                if (!/^\d+$/.test(value)) {
+                    return undefined;
+                }
+                const parsed = Number(value);
+                return Number.isSafeInteger(parsed) && parsed > 0
+                    ? parsed
+                    : undefined;
+            };
+            const page = parsePositiveInteger("page", 1);
+            const limit = parsePositiveInteger("limit", 20);
+            if (page === undefined || limit === undefined || limit > 100) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Page must be a positive integer and limit must be between 1 and 100",
+                }));
+                return;
+            }
+            if (!Number.isSafeInteger((page - 1) * limit)) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({
+                    message: "Page is out of range",
+                }));
+                return;
+            }
+            let summaries;
+            try {
+                summaries = this.storage.getPaginatedTraceSummaries(page, limit);
+            }
+            catch (error) {
+                (0, logger_1.debugLog)("Trace summary lookup failed", {
+                    errorName: error instanceof Error ? error.name : typeof error,
+                });
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ message: "Unable to read trace summaries" }));
+                return;
+            }
+            const { summaries: traceSummaries, total } = summaries;
+            const data = traceSummaries.map(summary => ({
+                id: summary.traceId,
+                method: summary.method ?? "UNKNOWN",
+                path: summary.path ?? "",
+                route: summary.route,
+                statusCode: summary.statusCode,
+                durationMs: summary.durationMs,
+                startedAt: summary.startedAt,
+                hasError: summary.hasError,
+                user: summary.user,
+            }));
+            const totalPages = Math.ceil(total / limit);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({
+                data,
+                pagination: {
+                    page,
+                    limit,
+                    total,
+                    totalPages,
+                    hasMore: page < totalPages,
+                },
+            }));
+            return;
+        }
+        if (req.method === "GET" &&
+            (pathname === "/_devtools" || pathname.startsWith("/_devtools/")) &&
+            !pathname.startsWith("/_devtools/api/") &&
+            pathname !== "/_devtools/api") {
+            const relativePath = pathname === "/_devtools" || pathname === "/_devtools/"
+                ? "index.html"
+                : pathname.slice("/_devtools/".length);
+            try {
+                const decodedPath = decodeURIComponent(relativePath);
+                const filePath = node_path_1.default.resolve(dashboardDirectory, decodedPath);
+                if (filePath !== dashboardDirectory && !filePath.startsWith(`${dashboardDirectory}${node_path_1.default.sep}`)) {
+                    res.statusCode = 404;
+                    res.end("Not Found");
+                    return;
+                }
+                const content = (0, node_fs_1.readFileSync)(filePath);
+                res.statusCode = 200;
+                res.setHeader("Content-Type", contentTypes[node_path_1.default.extname(filePath)] ?? "application/octet-stream");
+                res.end(content);
+                return;
+            }
+            catch {
+                res.statusCode = 404;
+                res.end("Not Found");
+                return;
+            }
+        }
+        res.statusCode = 404;
+        res.end("Not Found");
+    }
+}
+exports.default = DashboardServer;
+//# sourceMappingURL=dashboard-server.js.map