@lensjs/express 1.0.1

package/dist/adapter.cjs

@@ -0,0 +1,160 @@
+"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);
+var adapter_exports = {};
+__export(adapter_exports, {
+  default: () => ExpressAdapter
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_core = require("@lensjs/core");
+var path = __toESM(require("path"), 1);
+var import_express2 = __toESM(require("express"), 1);
+class ExpressAdapter extends import_core.LensAdapter {
+  app;
+  config;
+  constructor({ app }) {
+    super();
+    this.app = app;
+  }
+  setConfig(config) {
+    this.config = config;
+    return this;
+  }
+  setup() {
+    for (const watcher of this.getWatchers()) {
+      switch (watcher.name) {
+        case import_core.WatcherTypeEnum.REQUEST:
+          this.watchRequests(watcher);
+          break;
+        case import_core.WatcherTypeEnum.QUERY:
+          void this.watchQueries(watcher);
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app[route.method.toLowerCase()](
+        this.normalizePath(route.path),
+        async (req, res) => {
+          const result = await route.handler({
+            params: req.params,
+            qs: req.query
+          });
+          return res.json(result);
+        }
+      );
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.use(this.normalizePath(spaRoute), import_express2.default.static(uiPath));
+    this.app.get(
+      this.normalizePath(`${spaRoute}/favicon.svg`),
+      (_, res) => res.sendFile(path.join(uiPath, "favicon.svg"))
+    );
+    this.app.get(new RegExp(`^/${spaRoute}(?!/api)(/.*)?$`), (req, res) => {
+      if (import_core.lensUtils.isStaticFile(req.path.split("/"))) {
+        return res.download(
+          path.join(uiPath, import_core.lensUtils.stripBeforeAssetsPath(req.path))
+        );
+      }
+      return res.sendFile(path.join(uiPath, "index.html"));
+    });
+  }
+  async watchQueries(watcher) {
+    if (!this.config.queryWatcher.enabled) return;
+    const handler = this.config.queryWatcher.handler;
+    await handler({
+      onQuery: async (query) => {
+        const queryPayload = {
+          query: query.query,
+          duration: query.duration || "0 ms",
+          createdAt: query.createdAt || import_core.lensUtils.sqlDateTime(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.use((req, res, next) => {
+      if (this.shouldIgnorePath(req.path)) return next();
+      const start = process.hrtime();
+      this.patchResponseMethods(res);
+      res.on("finish", async () => {
+        await this.finalizeRequestLog(req, res, requestWatcher, start);
+      });
+      next();
+    });
+  }
+  patchResponseMethods(res) {
+    const originalJson = res.json.bind(res);
+    const originalSend = res.send.bind(res);
+    res._body = void 0;
+    res.json = function(body) {
+      res._body = body;
+      return originalJson(body);
+    };
+    res.send = function(body) {
+      res._body = body;
+      return originalSend(body);
+    };
+  }
+  async finalizeRequestLog(req, res, requestWatcher, start) {
+    try {
+      const duration = import_core.lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: import_core.lensUtils.generateRandomUuid(),
+          method: req.method,
+          duration,
+          path: req.originalUrl,
+          headers: req.headers,
+          body: req.body ?? {},
+          status: res.statusCode,
+          ip: req.socket?.remoteAddress ?? "",
+          createdAt: import_core.lensUtils.nowISO()
+        },
+        response: {
+          json: res._body ?? null,
+          headers: res.getHeaders?.()
+        },
+        user: await this.config.isAuthenticated?.(req) ? await this.config.getUser?.(req) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+}

package/dist/adapter.d.cts

@@ -0,0 +1,23 @@
+import { LensAdapter, RouteDefinition } from '@lensjs/core';
+import { RequiredExpressAdapterConfig } from './types/index.cjs';
+import { Express } from 'express';
+import '@lensjs/watchers';
+
+declare class ExpressAdapter extends LensAdapter {
+    protected app: Express;
+    protected config: RequiredExpressAdapterConfig;
+    constructor({ app }: {
+        app: Express;
+    });
+    setConfig(config: RequiredExpressAdapterConfig): this;
+    setup(): void;
+    registerRoutes(routes: RouteDefinition[]): void;
+    serveUI(uiPath: string, spaRoute: string, _dataToInject: Record<string, any>): void;
+    private watchQueries;
+    private watchRequests;
+    private patchResponseMethods;
+    private finalizeRequestLog;
+    private normalizePath;
+}
+
+export { ExpressAdapter as default };

package/dist/adapter.d.ts

@@ -0,0 +1,23 @@
+import { LensAdapter, RouteDefinition } from '@lensjs/core';
+import { RequiredExpressAdapterConfig } from './types/index.js';
+import { Express } from 'express';
+import '@lensjs/watchers';
+
+declare class ExpressAdapter extends LensAdapter {
+    protected app: Express;
+    protected config: RequiredExpressAdapterConfig;
+    constructor({ app }: {
+        app: Express;
+    });
+    setConfig(config: RequiredExpressAdapterConfig): this;
+    setup(): void;
+    registerRoutes(routes: RouteDefinition[]): void;
+    serveUI(uiPath: string, spaRoute: string, _dataToInject: Record<string, any>): void;
+    private watchQueries;
+    private watchRequests;
+    private patchResponseMethods;
+    private finalizeRequestLog;
+    private normalizePath;
+}
+
+export { ExpressAdapter as default };

package/dist/adapter.js

@@ -0,0 +1,134 @@
+import {
+  LensAdapter,
+  lensUtils,
+  WatcherTypeEnum
+} from "@lensjs/core";
+import * as path from "path";
+import express from "express";
+class ExpressAdapter extends LensAdapter {
+  app;
+  config;
+  constructor({ app }) {
+    super();
+    this.app = app;
+  }
+  setConfig(config) {
+    this.config = config;
+    return this;
+  }
+  setup() {
+    for (const watcher of this.getWatchers()) {
+      switch (watcher.name) {
+        case WatcherTypeEnum.REQUEST:
+          this.watchRequests(watcher);
+          break;
+        case WatcherTypeEnum.QUERY:
+          void this.watchQueries(watcher);
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app[route.method.toLowerCase()](
+        this.normalizePath(route.path),
+        async (req, res) => {
+          const result = await route.handler({
+            params: req.params,
+            qs: req.query
+          });
+          return res.json(result);
+        }
+      );
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.use(this.normalizePath(spaRoute), express.static(uiPath));
+    this.app.get(
+      this.normalizePath(`${spaRoute}/favicon.svg`),
+      (_, res) => res.sendFile(path.join(uiPath, "favicon.svg"))
+    );
+    this.app.get(new RegExp(`^/${spaRoute}(?!/api)(/.*)?$`), (req, res) => {
+      if (lensUtils.isStaticFile(req.path.split("/"))) {
+        return res.download(
+          path.join(uiPath, lensUtils.stripBeforeAssetsPath(req.path))
+        );
+      }
+      return res.sendFile(path.join(uiPath, "index.html"));
+    });
+  }
+  async watchQueries(watcher) {
+    if (!this.config.queryWatcher.enabled) return;
+    const handler = this.config.queryWatcher.handler;
+    await handler({
+      onQuery: async (query) => {
+        const queryPayload = {
+          query: query.query,
+          duration: query.duration || "0 ms",
+          createdAt: query.createdAt || lensUtils.sqlDateTime(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.use((req, res, next) => {
+      if (this.shouldIgnorePath(req.path)) return next();
+      const start = process.hrtime();
+      this.patchResponseMethods(res);
+      res.on("finish", async () => {
+        await this.finalizeRequestLog(req, res, requestWatcher, start);
+      });
+      next();
+    });
+  }
+  patchResponseMethods(res) {
+    const originalJson = res.json.bind(res);
+    const originalSend = res.send.bind(res);
+    res._body = void 0;
+    res.json = function(body) {
+      res._body = body;
+      return originalJson(body);
+    };
+    res.send = function(body) {
+      res._body = body;
+      return originalSend(body);
+    };
+  }
+  async finalizeRequestLog(req, res, requestWatcher, start) {
+    try {
+      const duration = lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: lensUtils.generateRandomUuid(),
+          method: req.method,
+          duration,
+          path: req.originalUrl,
+          headers: req.headers,
+          body: req.body ?? {},
+          status: res.statusCode,
+          ip: req.socket?.remoteAddress ?? "",
+          createdAt: lensUtils.nowISO()
+        },
+        response: {
+          json: res._body ?? null,
+          headers: res.getHeaders?.()
+        },
+        user: await this.config.isAuthenticated?.(req) ? await this.config.getUser?.(req) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+}
+export {
+  ExpressAdapter as default
+};

package/dist/index.cjs

@@ -0,0 +1,67 @@
+"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);
+var index_exports = {};
+__export(index_exports, {
+  lens: () => lens
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@lensjs/core");
+var import_adapter = __toESM(require("./adapter"), 1);
+const defaultConfig = {
+  appName: "Lens",
+  enabled: true,
+  path: "/lens",
+  ignoredPaths: [],
+  onlyPaths: []
+};
+const lens = async (config) => {
+  const adapter = new import_adapter.default({ app: config.app });
+  const watchers = [new import_core.RequestWatcher()];
+  const mergedConfig = {
+    ...config,
+    ...defaultConfig
+  };
+  if (config.queryWatcher?.enabled) {
+    watchers.push(new import_core.QueryWatcher());
+  }
+  const { ignoredPaths, normalizedPath } = import_core.lensUtils.prepareIgnoredPaths(
+    mergedConfig.path,
+    mergedConfig.ignoredPaths
+  );
+  adapter.setConfig(mergedConfig).setIgnoredPaths(ignoredPaths).setOnlyPaths(mergedConfig.onlyPaths);
+  await import_core.Lens.setAdapter(adapter).setWatchers(watchers).start({
+    appName: mergedConfig.appName,
+    enabled: mergedConfig.enabled,
+    basePath: normalizedPath
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lens
+});

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { ExpressAdapterConfig } from './types/index.cjs';
+import 'express';
+import '@lensjs/watchers';
+import '@lensjs/core';
+
+declare const lens: (config: ExpressAdapterConfig) => Promise<void>;
+
+export { lens };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { ExpressAdapterConfig } from './types/index.js';
+import 'express';
+import '@lensjs/watchers';
+import '@lensjs/core';
+
+declare const lens: (config: ExpressAdapterConfig) => Promise<void>;
+
+export { lens };

package/dist/index.js

@@ -0,0 +1,38 @@
+import {
+  Lens,
+  lensUtils,
+  QueryWatcher,
+  RequestWatcher
+} from "@lensjs/core";
+import ExpressAdapter from "./adapter";
+const defaultConfig = {
+  appName: "Lens",
+  enabled: true,
+  path: "/lens",
+  ignoredPaths: [],
+  onlyPaths: []
+};
+const lens = async (config) => {
+  const adapter = new ExpressAdapter({ app: config.app });
+  const watchers = [new RequestWatcher()];
+  const mergedConfig = {
+    ...config,
+    ...defaultConfig
+  };
+  if (config.queryWatcher?.enabled) {
+    watchers.push(new QueryWatcher());
+  }
+  const { ignoredPaths, normalizedPath } = lensUtils.prepareIgnoredPaths(
+    mergedConfig.path,
+    mergedConfig.ignoredPaths
+  );
+  adapter.setConfig(mergedConfig).setIgnoredPaths(ignoredPaths).setOnlyPaths(mergedConfig.onlyPaths);
+  await Lens.setAdapter(adapter).setWatchers(watchers).start({
+    appName: mergedConfig.appName,
+    enabled: mergedConfig.enabled,
+    basePath: normalizedPath
+  });
+};
+export {
+  lens
+};

package/dist/types/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/types/index.d.cts

@@ -0,0 +1,26 @@
+import { Express, Request } from 'express';
+import { QueryWatcherHandler } from '@lensjs/watchers';
+import { UserEntry } from '@lensjs/core';
+
+type ExpressAdapterConfig = {
+    app: Express;
+    appName?: string;
+    enabled?: boolean;
+    path?: string;
+    ignoredPaths?: RegExp[];
+    onlyPaths?: RegExp[];
+    requestWatcherEnabled?: boolean;
+    queryWatcher?: {
+        enabled: boolean;
+        handler: QueryWatcherHandler;
+    };
+    isAuthenticated?: (request: Request) => Promise<boolean>;
+    getUser?: (request: Request) => Promise<UserEntry>;
+};
+type RequiredExpressAdapterConfig = Required<ExpressAdapterConfig> & {
+    queryWatcher?: ExpressAdapterConfig["queryWatcher"];
+    isAuthenticated?: ExpressAdapterConfig["isAuthenticated"];
+    getUser?: ExpressAdapterConfig["getUser"];
+};
+
+export type { ExpressAdapterConfig, RequiredExpressAdapterConfig };

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+import { Express, Request } from 'express';
+import { QueryWatcherHandler } from '@lensjs/watchers';
+import { UserEntry } from '@lensjs/core';
+
+type ExpressAdapterConfig = {
+    app: Express;
+    appName?: string;
+    enabled?: boolean;
+    path?: string;
+    ignoredPaths?: RegExp[];
+    onlyPaths?: RegExp[];
+    requestWatcherEnabled?: boolean;
+    queryWatcher?: {
+        enabled: boolean;
+        handler: QueryWatcherHandler;
+    };
+    isAuthenticated?: (request: Request) => Promise<boolean>;
+    getUser?: (request: Request) => Promise<UserEntry>;
+};
+type RequiredExpressAdapterConfig = Required<ExpressAdapterConfig> & {
+    queryWatcher?: ExpressAdapterConfig["queryWatcher"];
+    isAuthenticated?: ExpressAdapterConfig["isAuthenticated"];
+    getUser?: ExpressAdapterConfig["getUser"];
+};
+
+export type { ExpressAdapterConfig, RequiredExpressAdapterConfig };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lensjs/express",
+  "version": "1.0.1",
+  "description": "Express adapter for Lens",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup --clean"
+  },
+  "dependencies": {
+    "express": "^5.1.0",
+    "utf-8-validate": "^6.0.5"
+  },
+  "trustedDependencies": [
+    "utf-8-validate"
+  ],
+  "devDependencies": {
+    "@types/express": "^5.0.3"
+  },
+  "gitHead": "a229fde5700970ec290ff31f1e3b7d84cc56d325"
+}