node-lens/dist/index.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/index.ts
var index_exports = {};
__export(index_exports, {
  clear: () => clear,
  getQueries: () => getQueries,
  getQueryByRequestId: () => getQueryByRequestId,
  getRecentQueries: () => getRecentQueries,
  getRecentRequests: () => getRecentRequests,
  getRequestById: () => getRequestById,
  getRequestQueries: () => getRequestQueries,
  getRequests: () => getRequests,
  logQuery: () => logQuery,
  logRequest: () => logRequest
});
module.exports = __toCommonJS(index_exports);

// src/logger/context.ts
var import_node_async_hooks = require("async_hooks");
var store = new import_node_async_hooks.AsyncLocalStorage();
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 clear() {
  import_node_fs.default.writeFileSync(logPath, "");
}
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 getRequestQueries(requestId) {
  return getEntries((entry) => entry.type === "query" && entry.requestId === requestId);
}
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];
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  clear,
  getQueries,
  getQueryByRequestId,
  getRecentQueries,
  getRecentRequests,
  getRequestById,
  getRequestQueries,
  getRequests,
  logQuery,
  logRequest
});