@lensjs/fastify 1.0.1

package/README.md

@@ -0,0 +1,71 @@
+# @lensjs/fastify
+
+Fastify adapter for Lens. This package provides middleware and integration points to connect your Fastify application with the Lens monitoring and debugging tool. It enables automatic logging of requests, queries (via `@lensjs/watchers`), and cache events.
+
+## Features
+
+*   **`lens(config: FastifyAdapterConfig)` function**: The main entry point to initialize and integrate Lens with a Fastify application.
+*   **`FastifyAdapter` class**: Extends `LensAdapter` from `@lensjs/core` to provide Fastify-specific implementations for setting up watchers, registering routes, and serving the Lens UI.
+*   **Request Watching**: Automatically captures incoming request details (method, path, headers, body, status, duration, IP) and logs them.
+*   **Query Watching**: Integrates with `@lensjs/watchers` to capture database queries from various ORMs (Kysely, Prisma, Sequelize) if configured.
+*   **Cache Watching**: Integrates with `@lensjs/watchers` to capture cache events if configured.
+*   **Exception Watching**: Captures and logs unhandled exceptions and errors within your Fastify application.
+*   **UI Serving**: Serves the Lens UI within your Fastify application at a configurable path.
+*   **Configurable Paths**: Allows specifying base paths, ignored paths, and only paths for request watching.
+*   **Body Purging**: Prevents sensitive information from being logged in responses by purging certain body types (e.g., file paths, binary data).
+*   **Authentication/User Context**: Supports optional `isAuthenticated` and `getUser` functions to associate request logs with authenticated users.
+
+## Installation
+
+```bash
+pnpm add @lensjs/fastify
+```
+
+## Usage Example
+
+```typescript
+import Fastify from 'fastify';
+import { lens } from '@lensjs/fastify';
+// import { createKyselyHandler } from '@lensjs/watchers/query/kysely'; // Example for Kysely
+
+const fastify = Fastify({
+  logger: true
+});
+
+// Initialize Lens with Fastify
+lens({
+  fastify,
+  appName: 'My Fastify App',
+  enabled: true, // Set to false in production
+  path: '/lens-dashboard', // Access Lens UI at /lens-dashboard
+  requestWatcherEnabled: true,
+  cacheWatcherEnabled: true,
+  exceptionWatcherEnabled: true,
+  // queryWatcher: {
+  //   enabled: true,
+  //   handler: createKyselyHandler({ provider: 'sqlite' }), // Or createPrismaHandler, createSequelizeHandler
+  // },
+  // Optional: Integrate with your authentication system
+  isAuthenticated: async (req) => {
+    return !!req.headers.authorization;
+  },
+  getUser: async (req) => {
+    // Return user details based on your auth system
+    return { id: '1', name: 'Authenticated User' };
+  },
+});
+
+// Your Fastify routes
+fastify.get('/', async (request, reply) => {
+  return { hello: 'world' };
+});
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+  console.log(`Fastify app listening on ${address}`);
+  console.log('Lens UI available at http://localhost:3000/lens-dashboard');
+});
+```

package/dist/adapter.cjs

@@ -0,0 +1,236 @@
+"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/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  FastifyAdapter: () => FastifyAdapter
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_core = require("@lensjs/core");
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var import_date = require("@lensjs/date");
+var import_static = __toESM(require("@fastify/static"), 1);
+var FastifyAdapter = class 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:
+          if (this.config.requestWatcherEnabled) {
+            this.watchRequests(watcher);
+          }
+          break;
+        case import_core.WatcherTypeEnum.QUERY:
+          if (this.config.queryWatcher?.enabled) {
+            void this.watchQueries(watcher);
+          }
+          break;
+        case import_core.WatcherTypeEnum.CACHE:
+          if (this.config.cacheWatcherEnabled) {
+            void this.watchCache(watcher);
+          }
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app.route({
+        method: route.method.toUpperCase(),
+        url: this.normalizePath(route.path),
+        handler: async (request, reply) => {
+          const result = await route.handler({
+            params: request.params,
+            qs: request.query
+          });
+          return reply.send(result);
+        }
+      });
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.register(import_static.default, {
+      root: uiPath,
+      prefix: `${this.normalizePath(import_core.lensUtils.normalizePath(spaRoute))}/`,
+      wildcard: false,
+      serve: false
+    });
+    this.app.get(`/${spaRoute}/*`, async (request, reply) => {
+      const url = request.url;
+      if (import_core.lensUtils.isStaticFile(url.split("/"))) {
+        const filePath = path.join(
+          uiPath,
+          import_core.lensUtils.stripBeforeAssetsPath(url)
+        );
+        return reply.sendFile(`${path.relative(uiPath, filePath)}`);
+      }
+      return reply.sendFile("index.html", uiPath);
+    });
+  }
+  async watchCache(watcher) {
+    if (!this.config.cacheWatcherEnabled) return;
+    import_core.lensEmitter.on("cache", async (data) => {
+      await watcher?.log(data);
+    });
+  }
+  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 || (0, import_date.nowISO)(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload,
+          requestId: import_core.lensContext.getStore()?.requestId ?? ""
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.addHook(
+      "onRequest",
+      (request, _, done) => {
+        if (this.shouldIgnorePath(request.url)) return done();
+        const context = {
+          requestId: import_core.lensUtils.generateRandomUuid()
+        };
+        request.lensContext = context;
+        request.lensStartTime = process.hrtime();
+        import_core.lensContext.run(context, done);
+      }
+    );
+    this.app.addHook(
+      "onSend",
+      async (request, reply, payload) => {
+        if (this.shouldIgnorePath(request.url)) return payload;
+        reply._lensBody = this.parseResponsePayload(payload);
+        return payload;
+      }
+    );
+    this.app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        if (this.shouldIgnorePath(request.url)) return;
+        const startTime = request.lensStartTime;
+        await this.finalizeRequestLog(
+          request,
+          reply,
+          requestWatcher,
+          startTime
+        );
+      }
+    );
+  }
+  async finalizeRequestLog(request, reply, requestWatcher, start) {
+    try {
+      const duration = import_core.lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: import_core.lensContext.getStore()?.requestId || import_core.lensUtils.generateRandomUuid(),
+          method: request.method,
+          duration,
+          path: request.url,
+          headers: request.headers,
+          body: request.body ?? {},
+          status: reply.statusCode,
+          ip: request.ip ?? "",
+          createdAt: (0, import_date.nowISO)()
+        },
+        response: {
+          json: this.parseBody(reply._lensBody),
+          headers: reply.getHeaders()
+        },
+        user: await this.config.isAuthenticated?.(request) ? await this.config.getUser?.(request) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  parseResponsePayload(payload) {
+    if (!payload) {
+      return null;
+    }
+    try {
+      if (typeof payload === "string") {
+        try {
+          return JSON.parse(payload);
+        } catch {
+          const filePath = path.resolve(payload);
+          if (fs.existsSync(filePath)) {
+            return "Purged By Lens";
+          }
+          return "Purged By Lens";
+        }
+      } else if (Buffer.isBuffer(payload)) {
+        return "Purged By Lens";
+      } else if (typeof payload === "object") {
+        return payload;
+      } else {
+        return payload;
+      }
+    } catch {
+      return "Purged By Lens";
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+  parseBody(body) {
+    if (!body) {
+      return null;
+    }
+    try {
+      return JSON.parse(body);
+    } catch (_e) {
+      return body;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FastifyAdapter
+});

package/dist/adapter.d.cts

@@ -0,0 +1,26 @@
+import { LensAdapter, RouteDefinition } from '@lensjs/core';
+import { RequiredFastifyAdapterConfig } from './types.cjs';
+import { FastifyInstance } from 'fastify';
+import '@lensjs/watchers';
+import '@fastify/static';
+
+declare class FastifyAdapter extends LensAdapter {
+    protected app: FastifyInstance;
+    protected config: RequiredFastifyAdapterConfig;
+    constructor({ app }: {
+        app: FastifyInstance;
+    });
+    setConfig(config: RequiredFastifyAdapterConfig): this;
+    setup(): void;
+    registerRoutes(routes: RouteDefinition[]): void;
+    serveUI(uiPath: string, spaRoute: string, _dataToInject: Record<string, any>): void;
+    private watchCache;
+    private watchQueries;
+    private watchRequests;
+    private finalizeRequestLog;
+    private parseResponsePayload;
+    private normalizePath;
+    private parseBody;
+}
+
+export { FastifyAdapter };

package/dist/adapter.d.ts

@@ -0,0 +1,26 @@
+import { LensAdapter, RouteDefinition } from '@lensjs/core';
+import { RequiredFastifyAdapterConfig } from './types.js';
+import { FastifyInstance } from 'fastify';
+import '@lensjs/watchers';
+import '@fastify/static';
+
+declare class FastifyAdapter extends LensAdapter {
+    protected app: FastifyInstance;
+    protected config: RequiredFastifyAdapterConfig;
+    constructor({ app }: {
+        app: FastifyInstance;
+    });
+    setConfig(config: RequiredFastifyAdapterConfig): this;
+    setup(): void;
+    registerRoutes(routes: RouteDefinition[]): void;
+    serveUI(uiPath: string, spaRoute: string, _dataToInject: Record<string, any>): void;
+    private watchCache;
+    private watchQueries;
+    private watchRequests;
+    private finalizeRequestLog;
+    private parseResponsePayload;
+    private normalizePath;
+    private parseBody;
+}
+
+export { FastifyAdapter };

package/dist/adapter.js

@@ -0,0 +1,207 @@
+// src/adapter.ts
+import {
+  LensAdapter,
+  lensUtils,
+  WatcherTypeEnum,
+  lensContext,
+  lensEmitter
+} from "@lensjs/core";
+import * as path from "path";
+import * as fs from "fs";
+import { nowISO } from "@lensjs/date";
+import fastifyStatic from "@fastify/static";
+var FastifyAdapter = class 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:
+          if (this.config.requestWatcherEnabled) {
+            this.watchRequests(watcher);
+          }
+          break;
+        case WatcherTypeEnum.QUERY:
+          if (this.config.queryWatcher?.enabled) {
+            void this.watchQueries(watcher);
+          }
+          break;
+        case WatcherTypeEnum.CACHE:
+          if (this.config.cacheWatcherEnabled) {
+            void this.watchCache(watcher);
+          }
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app.route({
+        method: route.method.toUpperCase(),
+        url: this.normalizePath(route.path),
+        handler: async (request, reply) => {
+          const result = await route.handler({
+            params: request.params,
+            qs: request.query
+          });
+          return reply.send(result);
+        }
+      });
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.register(fastifyStatic, {
+      root: uiPath,
+      prefix: `${this.normalizePath(lensUtils.normalizePath(spaRoute))}/`,
+      wildcard: false,
+      serve: false
+    });
+    this.app.get(`/${spaRoute}/*`, async (request, reply) => {
+      const url = request.url;
+      if (lensUtils.isStaticFile(url.split("/"))) {
+        const filePath = path.join(
+          uiPath,
+          lensUtils.stripBeforeAssetsPath(url)
+        );
+        return reply.sendFile(`${path.relative(uiPath, filePath)}`);
+      }
+      return reply.sendFile("index.html", uiPath);
+    });
+  }
+  async watchCache(watcher) {
+    if (!this.config.cacheWatcherEnabled) return;
+    lensEmitter.on("cache", async (data) => {
+      await watcher?.log(data);
+    });
+  }
+  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 || nowISO(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload,
+          requestId: lensContext.getStore()?.requestId ?? ""
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.addHook(
+      "onRequest",
+      (request, _, done) => {
+        if (this.shouldIgnorePath(request.url)) return done();
+        const context = {
+          requestId: lensUtils.generateRandomUuid()
+        };
+        request.lensContext = context;
+        request.lensStartTime = process.hrtime();
+        lensContext.run(context, done);
+      }
+    );
+    this.app.addHook(
+      "onSend",
+      async (request, reply, payload) => {
+        if (this.shouldIgnorePath(request.url)) return payload;
+        reply._lensBody = this.parseResponsePayload(payload);
+        return payload;
+      }
+    );
+    this.app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        if (this.shouldIgnorePath(request.url)) return;
+        const startTime = request.lensStartTime;
+        await this.finalizeRequestLog(
+          request,
+          reply,
+          requestWatcher,
+          startTime
+        );
+      }
+    );
+  }
+  async finalizeRequestLog(request, reply, requestWatcher, start) {
+    try {
+      const duration = lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: lensContext.getStore()?.requestId || lensUtils.generateRandomUuid(),
+          method: request.method,
+          duration,
+          path: request.url,
+          headers: request.headers,
+          body: request.body ?? {},
+          status: reply.statusCode,
+          ip: request.ip ?? "",
+          createdAt: nowISO()
+        },
+        response: {
+          json: this.parseBody(reply._lensBody),
+          headers: reply.getHeaders()
+        },
+        user: await this.config.isAuthenticated?.(request) ? await this.config.getUser?.(request) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  parseResponsePayload(payload) {
+    if (!payload) {
+      return null;
+    }
+    try {
+      if (typeof payload === "string") {
+        try {
+          return JSON.parse(payload);
+        } catch {
+          const filePath = path.resolve(payload);
+          if (fs.existsSync(filePath)) {
+            return "Purged By Lens";
+          }
+          return "Purged By Lens";
+        }
+      } else if (Buffer.isBuffer(payload)) {
+        return "Purged By Lens";
+      } else if (typeof payload === "object") {
+        return payload;
+      } else {
+        return payload;
+      }
+    } catch {
+      return "Purged By Lens";
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+  parseBody(body) {
+    if (!body) {
+      return null;
+    }
+    try {
+      return JSON.parse(body);
+    } catch (_e) {
+      return body;
+    }
+  }
+};
+export {
+  FastifyAdapter
+};

package/dist/index.cjs

@@ -0,0 +1,332 @@
+"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, {
+  FastifyAdapter: () => FastifyAdapter,
+  lens: () => lens
+});
+module.exports = __toCommonJS(index_exports);
+var import_core2 = require("@lensjs/core");
+
+// src/adapter.ts
+var import_core = require("@lensjs/core");
+var path = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var import_date = require("@lensjs/date");
+var import_static = __toESM(require("@fastify/static"), 1);
+var FastifyAdapter = class 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:
+          if (this.config.requestWatcherEnabled) {
+            this.watchRequests(watcher);
+          }
+          break;
+        case import_core.WatcherTypeEnum.QUERY:
+          if (this.config.queryWatcher?.enabled) {
+            void this.watchQueries(watcher);
+          }
+          break;
+        case import_core.WatcherTypeEnum.CACHE:
+          if (this.config.cacheWatcherEnabled) {
+            void this.watchCache(watcher);
+          }
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app.route({
+        method: route.method.toUpperCase(),
+        url: this.normalizePath(route.path),
+        handler: async (request, reply) => {
+          const result = await route.handler({
+            params: request.params,
+            qs: request.query
+          });
+          return reply.send(result);
+        }
+      });
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.register(import_static.default, {
+      root: uiPath,
+      prefix: `${this.normalizePath(import_core.lensUtils.normalizePath(spaRoute))}/`,
+      wildcard: false,
+      serve: false
+    });
+    this.app.get(`/${spaRoute}/*`, async (request, reply) => {
+      const url = request.url;
+      if (import_core.lensUtils.isStaticFile(url.split("/"))) {
+        const filePath = path.join(
+          uiPath,
+          import_core.lensUtils.stripBeforeAssetsPath(url)
+        );
+        return reply.sendFile(`${path.relative(uiPath, filePath)}`);
+      }
+      return reply.sendFile("index.html", uiPath);
+    });
+  }
+  async watchCache(watcher) {
+    if (!this.config.cacheWatcherEnabled) return;
+    import_core.lensEmitter.on("cache", async (data) => {
+      await watcher?.log(data);
+    });
+  }
+  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 || (0, import_date.nowISO)(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload,
+          requestId: import_core.lensContext.getStore()?.requestId ?? ""
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.addHook(
+      "onRequest",
+      (request, _, done) => {
+        if (this.shouldIgnorePath(request.url)) return done();
+        const context = {
+          requestId: import_core.lensUtils.generateRandomUuid()
+        };
+        request.lensContext = context;
+        request.lensStartTime = process.hrtime();
+        import_core.lensContext.run(context, done);
+      }
+    );
+    this.app.addHook(
+      "onSend",
+      async (request, reply, payload) => {
+        if (this.shouldIgnorePath(request.url)) return payload;
+        reply._lensBody = this.parseResponsePayload(payload);
+        return payload;
+      }
+    );
+    this.app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        if (this.shouldIgnorePath(request.url)) return;
+        const startTime = request.lensStartTime;
+        await this.finalizeRequestLog(
+          request,
+          reply,
+          requestWatcher,
+          startTime
+        );
+      }
+    );
+  }
+  async finalizeRequestLog(request, reply, requestWatcher, start) {
+    try {
+      const duration = import_core.lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: import_core.lensContext.getStore()?.requestId || import_core.lensUtils.generateRandomUuid(),
+          method: request.method,
+          duration,
+          path: request.url,
+          headers: request.headers,
+          body: request.body ?? {},
+          status: reply.statusCode,
+          ip: request.ip ?? "",
+          createdAt: (0, import_date.nowISO)()
+        },
+        response: {
+          json: this.parseBody(reply._lensBody),
+          headers: reply.getHeaders()
+        },
+        user: await this.config.isAuthenticated?.(request) ? await this.config.getUser?.(request) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  parseResponsePayload(payload) {
+    if (!payload) {
+      return null;
+    }
+    try {
+      if (typeof payload === "string") {
+        try {
+          return JSON.parse(payload);
+        } catch {
+          const filePath = path.resolve(payload);
+          if (fs.existsSync(filePath)) {
+            return "Purged By Lens";
+          }
+          return "Purged By Lens";
+        }
+      } else if (Buffer.isBuffer(payload)) {
+        return "Purged By Lens";
+      } else if (typeof payload === "object") {
+        return payload;
+      } else {
+        return payload;
+      }
+    } catch {
+      return "Purged By Lens";
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+  parseBody(body) {
+    if (!body) {
+      return null;
+    }
+    try {
+      return JSON.parse(body);
+    } catch (_e) {
+      return body;
+    }
+  }
+};
+
+// src/index.ts
+var import_core3 = require("@lensjs/core");
+var import_core4 = require("@lensjs/core");
+var defaultConfig = {
+  appName: "Lens",
+  enabled: true,
+  path: "/lens",
+  ignoredPaths: [],
+  onlyPaths: [],
+  requestWatcherEnabled: true,
+  cacheWatcherEnabled: false,
+  exceptionWatcherEnabled: true,
+  registerErrorHandler: true
+};
+var lens = async (config) => {
+  const adapter = new FastifyAdapter({ app: config.app });
+  const watchers = [];
+  const mergedConfig = {
+    ...defaultConfig,
+    ...config
+  };
+  const defaultWatchers = [
+    {
+      enabled: mergedConfig.requestWatcherEnabled,
+      watcher: new import_core2.RequestWatcher()
+    },
+    {
+      enabled: mergedConfig.cacheWatcherEnabled,
+      watcher: new import_core2.CacheWatcher()
+    },
+    {
+      enabled: mergedConfig.queryWatcher?.enabled,
+      watcher: new import_core2.QueryWatcher()
+    },
+    {
+      enabled: mergedConfig.exceptionWatcherEnabled,
+      watcher: new import_core2.ExceptionWatcher()
+    }
+  ];
+  defaultWatchers.forEach((watcher) => {
+    if (watcher.enabled) {
+      watchers.push(watcher.watcher);
+    }
+  });
+  const { ignoredPaths, normalizedPath } = import_core2.lensUtils.prepareIgnoredPaths(
+    mergedConfig.path,
+    mergedConfig.ignoredPaths
+  );
+  adapter.setConfig(mergedConfig).setIgnoredPaths(ignoredPaths).setOnlyPaths(mergedConfig.onlyPaths);
+  if (mergedConfig.exceptionWatcherEnabled && mergedConfig.registerErrorHandler) {
+    handleExceptions({
+      app: mergedConfig.app,
+      enabled: mergedConfig.exceptionWatcherEnabled && mergedConfig.enabled,
+      watcher: watchers.find(
+        (w) => w.name === import_core3.WatcherTypeEnum.EXCEPTION
+      )
+    });
+  }
+  await import_core2.Lens.setAdapter(adapter).setWatchers(watchers).start({
+    appName: mergedConfig.appName,
+    enabled: mergedConfig.enabled,
+    basePath: normalizedPath
+  });
+  const exceptionWatcher = watchers.find(
+    (w) => w.name === import_core3.WatcherTypeEnum.EXCEPTION
+  );
+  return {
+    logException: (error) => logException(
+      error,
+      mergedConfig.exceptionWatcherEnabled && mergedConfig.enabled,
+      exceptionWatcher
+    )
+  };
+};
+function logException(error, enabled, watcher) {
+  if (!enabled || !watcher) return;
+  watcher.log({
+    ...import_core4.lensExceptionUtils.constructErrorObject(error),
+    requestId: import_core2.lensContext.getStore()?.requestId ?? ""
+  });
+}
+function handleExceptions({
+  app,
+  enabled,
+  watcher
+}) {
+  app.setErrorHandler((err) => {
+    logException(err, enabled, watcher);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FastifyAdapter,
+  lens
+});

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+import { FastifyAdapterConfig } from './types.cjs';
+export { RequiredFastifyAdapterConfig } from './types.cjs';
+import { FastifyError } from 'fastify';
+export { FastifyAdapter } from './adapter.cjs';
+import '@lensjs/watchers';
+import '@lensjs/core';
+import '@fastify/static';
+
+declare const lens: (config: FastifyAdapterConfig) => Promise<{
+    logException: (error: FastifyError) => void;
+}>;
+
+export { FastifyAdapterConfig, lens };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { FastifyAdapterConfig } from './types.js';
+export { RequiredFastifyAdapterConfig } from './types.js';
+import { FastifyError } from 'fastify';
+export { FastifyAdapter } from './adapter.js';
+import '@lensjs/watchers';
+import '@lensjs/core';
+import '@fastify/static';
+
+declare const lens: (config: FastifyAdapterConfig) => Promise<{
+    logException: (error: FastifyError) => void;
+}>;
+
+export { FastifyAdapterConfig, lens };

package/dist/index.js

@@ -0,0 +1,310 @@
+// src/index.ts
+import {
+  CacheWatcher as CacheWatcher2,
+  ExceptionWatcher,
+  Lens,
+  lensContext as lensContext2,
+  lensUtils as lensUtils2,
+  QueryWatcher as QueryWatcher2,
+  RequestWatcher as RequestWatcher2
+} from "@lensjs/core";
+
+// src/adapter.ts
+import {
+  LensAdapter,
+  lensUtils,
+  WatcherTypeEnum,
+  lensContext,
+  lensEmitter
+} from "@lensjs/core";
+import * as path from "path";
+import * as fs from "fs";
+import { nowISO } from "@lensjs/date";
+import fastifyStatic from "@fastify/static";
+var FastifyAdapter = class 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:
+          if (this.config.requestWatcherEnabled) {
+            this.watchRequests(watcher);
+          }
+          break;
+        case WatcherTypeEnum.QUERY:
+          if (this.config.queryWatcher?.enabled) {
+            void this.watchQueries(watcher);
+          }
+          break;
+        case WatcherTypeEnum.CACHE:
+          if (this.config.cacheWatcherEnabled) {
+            void this.watchCache(watcher);
+          }
+          break;
+      }
+    }
+  }
+  registerRoutes(routes) {
+    routes.forEach((route) => {
+      this.app.route({
+        method: route.method.toUpperCase(),
+        url: this.normalizePath(route.path),
+        handler: async (request, reply) => {
+          const result = await route.handler({
+            params: request.params,
+            qs: request.query
+          });
+          return reply.send(result);
+        }
+      });
+    });
+  }
+  serveUI(uiPath, spaRoute, _dataToInject) {
+    this.app.register(fastifyStatic, {
+      root: uiPath,
+      prefix: `${this.normalizePath(lensUtils.normalizePath(spaRoute))}/`,
+      wildcard: false,
+      serve: false
+    });
+    this.app.get(`/${spaRoute}/*`, async (request, reply) => {
+      const url = request.url;
+      if (lensUtils.isStaticFile(url.split("/"))) {
+        const filePath = path.join(
+          uiPath,
+          lensUtils.stripBeforeAssetsPath(url)
+        );
+        return reply.sendFile(`${path.relative(uiPath, filePath)}`);
+      }
+      return reply.sendFile("index.html", uiPath);
+    });
+  }
+  async watchCache(watcher) {
+    if (!this.config.cacheWatcherEnabled) return;
+    lensEmitter.on("cache", async (data) => {
+      await watcher?.log(data);
+    });
+  }
+  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 || nowISO(),
+          type: query.type
+        };
+        await watcher?.log({
+          data: queryPayload,
+          requestId: lensContext.getStore()?.requestId ?? ""
+        });
+      }
+    });
+  }
+  watchRequests(requestWatcher) {
+    if (!this.config.requestWatcherEnabled) return;
+    this.app.addHook(
+      "onRequest",
+      (request, _, done) => {
+        if (this.shouldIgnorePath(request.url)) return done();
+        const context = {
+          requestId: lensUtils.generateRandomUuid()
+        };
+        request.lensContext = context;
+        request.lensStartTime = process.hrtime();
+        lensContext.run(context, done);
+      }
+    );
+    this.app.addHook(
+      "onSend",
+      async (request, reply, payload) => {
+        if (this.shouldIgnorePath(request.url)) return payload;
+        reply._lensBody = this.parseResponsePayload(payload);
+        return payload;
+      }
+    );
+    this.app.addHook(
+      "onResponse",
+      async (request, reply) => {
+        if (this.shouldIgnorePath(request.url)) return;
+        const startTime = request.lensStartTime;
+        await this.finalizeRequestLog(
+          request,
+          reply,
+          requestWatcher,
+          startTime
+        );
+      }
+    );
+  }
+  async finalizeRequestLog(request, reply, requestWatcher, start) {
+    try {
+      const duration = lensUtils.prettyHrTime(process.hrtime(start));
+      const logPayload = {
+        request: {
+          id: lensContext.getStore()?.requestId || lensUtils.generateRandomUuid(),
+          method: request.method,
+          duration,
+          path: request.url,
+          headers: request.headers,
+          body: request.body ?? {},
+          status: reply.statusCode,
+          ip: request.ip ?? "",
+          createdAt: nowISO()
+        },
+        response: {
+          json: this.parseBody(reply._lensBody),
+          headers: reply.getHeaders()
+        },
+        user: await this.config.isAuthenticated?.(request) ? await this.config.getUser?.(request) : null
+      };
+      await requestWatcher.log(logPayload);
+    } catch (err) {
+      console.error("Error finalizing request log:", err);
+    }
+  }
+  parseResponsePayload(payload) {
+    if (!payload) {
+      return null;
+    }
+    try {
+      if (typeof payload === "string") {
+        try {
+          return JSON.parse(payload);
+        } catch {
+          const filePath = path.resolve(payload);
+          if (fs.existsSync(filePath)) {
+            return "Purged By Lens";
+          }
+          return "Purged By Lens";
+        }
+      } else if (Buffer.isBuffer(payload)) {
+        return "Purged By Lens";
+      } else if (typeof payload === "object") {
+        return payload;
+      } else {
+        return payload;
+      }
+    } catch {
+      return "Purged By Lens";
+    }
+  }
+  normalizePath(pathStr) {
+    return pathStr.startsWith("/") ? pathStr : `/${pathStr}`;
+  }
+  parseBody(body) {
+    if (!body) {
+      return null;
+    }
+    try {
+      return JSON.parse(body);
+    } catch (_e) {
+      return body;
+    }
+  }
+};
+
+// src/index.ts
+import { WatcherTypeEnum as WatcherTypeEnum2 } from "@lensjs/core";
+import { lensExceptionUtils } from "@lensjs/core";
+var defaultConfig = {
+  appName: "Lens",
+  enabled: true,
+  path: "/lens",
+  ignoredPaths: [],
+  onlyPaths: [],
+  requestWatcherEnabled: true,
+  cacheWatcherEnabled: false,
+  exceptionWatcherEnabled: true,
+  registerErrorHandler: true
+};
+var lens = async (config) => {
+  const adapter = new FastifyAdapter({ app: config.app });
+  const watchers = [];
+  const mergedConfig = {
+    ...defaultConfig,
+    ...config
+  };
+  const defaultWatchers = [
+    {
+      enabled: mergedConfig.requestWatcherEnabled,
+      watcher: new RequestWatcher2()
+    },
+    {
+      enabled: mergedConfig.cacheWatcherEnabled,
+      watcher: new CacheWatcher2()
+    },
+    {
+      enabled: mergedConfig.queryWatcher?.enabled,
+      watcher: new QueryWatcher2()
+    },
+    {
+      enabled: mergedConfig.exceptionWatcherEnabled,
+      watcher: new ExceptionWatcher()
+    }
+  ];
+  defaultWatchers.forEach((watcher) => {
+    if (watcher.enabled) {
+      watchers.push(watcher.watcher);
+    }
+  });
+  const { ignoredPaths, normalizedPath } = lensUtils2.prepareIgnoredPaths(
+    mergedConfig.path,
+    mergedConfig.ignoredPaths
+  );
+  adapter.setConfig(mergedConfig).setIgnoredPaths(ignoredPaths).setOnlyPaths(mergedConfig.onlyPaths);
+  if (mergedConfig.exceptionWatcherEnabled && mergedConfig.registerErrorHandler) {
+    handleExceptions({
+      app: mergedConfig.app,
+      enabled: mergedConfig.exceptionWatcherEnabled && mergedConfig.enabled,
+      watcher: watchers.find(
+        (w) => w.name === WatcherTypeEnum2.EXCEPTION
+      )
+    });
+  }
+  await Lens.setAdapter(adapter).setWatchers(watchers).start({
+    appName: mergedConfig.appName,
+    enabled: mergedConfig.enabled,
+    basePath: normalizedPath
+  });
+  const exceptionWatcher = watchers.find(
+    (w) => w.name === WatcherTypeEnum2.EXCEPTION
+  );
+  return {
+    logException: (error) => logException(
+      error,
+      mergedConfig.exceptionWatcherEnabled && mergedConfig.enabled,
+      exceptionWatcher
+    )
+  };
+};
+function logException(error, enabled, watcher) {
+  if (!enabled || !watcher) return;
+  watcher.log({
+    ...lensExceptionUtils.constructErrorObject(error),
+    requestId: lensContext2.getStore()?.requestId ?? ""
+  });
+}
+function handleExceptions({
+  app,
+  enabled,
+  watcher
+}) {
+  app.setErrorHandler((err) => {
+    logException(err, enabled, watcher);
+  });
+}
+export {
+  FastifyAdapter,
+  lens
+};

package/dist/types.cjs

@@ -0,0 +1,18 @@
+"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);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/types.d.cts

@@ -0,0 +1,40 @@
+import { FastifyInstance, FastifyRequest } from 'fastify';
+import { QueryWatcherHandler } from '@lensjs/watchers';
+import { UserEntry } from '@lensjs/core';
+import { SendOptions } from '@fastify/static';
+
+type FastifyAdapterConfig = {
+    app: FastifyInstance;
+    appName?: string;
+    enabled?: boolean;
+    path?: string;
+    ignoredPaths?: RegExp[];
+    onlyPaths?: RegExp[];
+    requestWatcherEnabled?: boolean;
+    cacheWatcherEnabled?: boolean;
+    exceptionWatcherEnabled?: boolean;
+    registerErrorHandler?: boolean;
+    queryWatcher?: {
+        enabled: boolean;
+        handler: QueryWatcherHandler;
+    };
+    isAuthenticated?: (request: FastifyRequest) => Promise<boolean>;
+    getUser?: (request: FastifyRequest) => Promise<UserEntry>;
+};
+type RequiredFastifyAdapterConfig = Required<FastifyAdapterConfig> & {
+    queryWatcher?: FastifyAdapterConfig["queryWatcher"];
+    isAuthenticated?: FastifyAdapterConfig["isAuthenticated"];
+    getUser?: FastifyAdapterConfig["getUser"];
+};
+declare module "fastify" {
+    interface FastifyReply {
+        sendFile(filename: string, rootPath?: string): FastifyReply;
+        sendFile(filename: string, options?: SendOptions): FastifyReply;
+        sendFile(filename: string, rootPath?: string, options?: SendOptions): FastifyReply;
+        download(filepath: string, options?: SendOptions): FastifyReply;
+        download(filepath: string, filename?: string): FastifyReply;
+        download(filepath: string, filename?: string, options?: SendOptions): FastifyReply;
+    }
+}
+
+export type { FastifyAdapterConfig, RequiredFastifyAdapterConfig };

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import { FastifyInstance, FastifyRequest } from 'fastify';
+import { QueryWatcherHandler } from '@lensjs/watchers';
+import { UserEntry } from '@lensjs/core';
+import { SendOptions } from '@fastify/static';
+
+type FastifyAdapterConfig = {
+    app: FastifyInstance;
+    appName?: string;
+    enabled?: boolean;
+    path?: string;
+    ignoredPaths?: RegExp[];
+    onlyPaths?: RegExp[];
+    requestWatcherEnabled?: boolean;
+    cacheWatcherEnabled?: boolean;
+    exceptionWatcherEnabled?: boolean;
+    registerErrorHandler?: boolean;
+    queryWatcher?: {
+        enabled: boolean;
+        handler: QueryWatcherHandler;
+    };
+    isAuthenticated?: (request: FastifyRequest) => Promise<boolean>;
+    getUser?: (request: FastifyRequest) => Promise<UserEntry>;
+};
+type RequiredFastifyAdapterConfig = Required<FastifyAdapterConfig> & {
+    queryWatcher?: FastifyAdapterConfig["queryWatcher"];
+    isAuthenticated?: FastifyAdapterConfig["isAuthenticated"];
+    getUser?: FastifyAdapterConfig["getUser"];
+};
+declare module "fastify" {
+    interface FastifyReply {
+        sendFile(filename: string, rootPath?: string): FastifyReply;
+        sendFile(filename: string, options?: SendOptions): FastifyReply;
+        sendFile(filename: string, rootPath?: string, options?: SendOptions): FastifyReply;
+        download(filepath: string, options?: SendOptions): FastifyReply;
+        download(filepath: string, filename?: string): FastifyReply;
+        download(filepath: string, filename?: string, options?: SendOptions): FastifyReply;
+    }
+}
+
+export type { FastifyAdapterConfig, RequiredFastifyAdapterConfig };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lensjs/fastify",
+  "version": "1.0.1",
+  "description": "Fastify adapter for LensJs",
+  "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"
+  ],
+  "dependencies": {
+    "@fastify/static": "8.2.0",
+    "@lensjs/core": "2.2.0",
+    "@lensjs/date": "1.0.12",
+    "@lensjs/typescript-config": "1.0.12",
+    "@lensjs/watchers": "1.0.16"
+  },
+  "devDependencies": {
+    "fastify": "^5.6.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependencies": {
+    "fastify": "^5.2.1"
+  },
+  "scripts": {
+    "build": "tsup --clean",
+    "test": "vitest run"
+  }
+}