node-lens/dist/adapters/express.js

Lens is a lightweight developer tool for Node.js apps that lets you log, view, and debug requests and other activity in real time — inspired by Laravel Telescope.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/adapters/express.ts
var express_exports = {};
__export(express_exports, {
  createProxy: () => createProxy,
  getRequestId: () => getRequestId,
  lens: () => lens
});
module.exports = __toCommonJS(express_exports);
var import_express = __toESM(require("express"));
var import_node_path2 = __toESM(require("path"));

// src/logger/context.ts
var import_node_async_hooks = require("async_hooks");
var store = new import_node_async_hooks.AsyncLocalStorage();
function runWithRequestId(requestId, fn) {
  return store.run({ requestId }, fn);
}
function getRequestId() {
  return store.getStore()?.requestId;
}

// src/logger/store.ts
var import_node_fs = __toESM(require("fs"));
var import_node_path = __toESM(require("path"));
var logPath = import_node_path.default.join(process.cwd(), ".lens", "lens.ndjson");
import_node_fs.default.mkdirSync(import_node_path.default.dirname(logPath), { recursive: true });
var stream = import_node_fs.default.createWriteStream(logPath, { flags: "a" });
var buffer = [];
var FLUSH_INTERVAL = 100;
var flushTimeout = null;
process.on("exit", () => {
  flush();
});
function flush() {
  if (buffer.length) {
    stream.write(buffer.join(""));
    buffer.length = 0;
  }
  flushTimeout = null;
}
function append(entry) {
  buffer.push(JSON.stringify(entry) + "\n");
  if (!flushTimeout) {
    flushTimeout = setTimeout(flush, FLUSH_INTERVAL);
  }
}
function readLogs() {
  if (!import_node_fs.default.existsSync(logPath)) return [];
  const raw = import_node_fs.default.readFileSync(logPath, "utf8");
  return raw.split("\n").filter(Boolean).map((line) => {
    try {
      return JSON.parse(line);
    } catch {
      return null;
    }
  }).filter((entry) => Boolean(entry));
}
function getEntries(filterFn) {
  const parsed = readLogs();
  const filtered = filterFn ? parsed.filter(filterFn) : parsed;
  return filtered;
}

// src/logger/index.ts
function logRequest(data) {
  const entry = {
    ...data,
    type: "request",
    timestamp: Date.now()
  };
  append(entry);
}
function logQuery(data) {
  const requestId = getRequestId();
  const entry = {
    ...data,
    type: "query",
    timestamp: Date.now(),
    requestId
  };
  append(entry);
}
function getRequests() {
  const requests = getEntries((entry) => entry.type === "request");
  return requests;
}
function getQueries() {
  return getEntries((entry) => entry.type === "query");
}
function getRequestById(id) {
  return getEntries((e) => e.type === "request" && e.requestId === id)[0];
}
function getRecentRequests(limit = 50) {
  return getRequests().slice(-limit).reverse();
}
function getRecentQueries(limit = 50) {
  return getQueries().slice(-limit).reverse();
}
function getQueryByRequestId(id) {
  return getEntries((e) => e.type === "query" && e.requestId === id)[0];
}

// src/logger/proxy.ts
function createProxy(client, options) {
  return new Proxy(client, {
    get(target, prop, receiver) {
      const original = Reflect.get(target, prop, receiver);
      if (typeof original !== "function") {
        return original;
      }
      return function(...args) {
        if (typeof prop === "string" && options.methods.includes(prop)) {
          logQuery({ query: args[0], durationMs: 100 });
        }
        return original.apply(target, args);
      };
    }
  });
}

// src/adapters/express.ts
async function middleware(req, res, next) {
  const requestId = crypto.randomUUID();
  runWithRequestId(requestId, () => {
    const memoryUsageMb = process.memoryUsage().rss / 1024 / 1024;
    const start = process.hrtime();
    res.on("finish", async () => {
      const end = process.hrtime(start);
      logRequest({
        method: req.method,
        status: res.statusCode,
        path: req.path,
        requestId,
        ip: req.ip ?? "-",
        memoryUsageMb,
        durationMs: end[0] * 1e3 + end[1] / 1e6,
        request: {
          headers: req.headers,
          body: req.body
        },
        response: {
          headers: res.getHeaders()
          // TODO: get response body
        }
      });
    });
    next();
  });
}
function routes() {
  const router = import_express.default.Router();
  const uiPath = import_node_path2.default.resolve(__dirname, "..", "ui");
  router.use(import_express.default.static(uiPath));
  router.get("/api/requests", (_, res) => {
    res.json(getRecentRequests());
  });
  router.get("/api/requests/:id", (req, res) => {
    const { id } = req.params;
    res.json(getRequestById(id));
  });
  router.get("/api/queries", (_, res) => {
    res.json(getRecentQueries());
  });
  router.get("/api/queries/:id", (req, res) => {
    const { id } = req.params;
    res.json(getQueryByRequestId(id));
  });
  router.use("/{*splat}", (_, res) => {
    res.sendFile(import_node_path2.default.join(uiPath, "index.html"));
  });
  return router;
}
function lens(options = {}) {
  const path3 = options.path || "/lens";
  const router = import_express.default.Router();
  router.get("/lens-config", (_, res) => {
    res.json({ path: path3 });
  });
  router.use(path3, routes());
  router.use(middleware);
  return router;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createProxy,
  getRequestId,
  lens
});