open-index/open-npm huggingface dataset:
npm package: @lensjs/fastify
Description: Fastify adapter for LensJs
Latest version: 1.2.0

# @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');
});
```
npm package: @lensjs/watchers
Description: Watcher handlers for Lens
Latest version: 1.2.0

# @lensjs/watchers

Watcher handlers for Lens. This package provides integrations for various ORMs/query builders (Kysely, Prisma, Sequelize) to emit query and cache events, allowing Lens to observe and log database interactions.

## Features

*   **`createKyselyHandler`**: Integrates with Kysely to capture and format database queries.
*   **`createPrismaHandler`**: Integrates with Prisma to capture and format database queries, with support for different Prisma providers (e.g., SQLite, PostgreSQL, MongoDB).
*   **`createSequelizeHandler`**: Integrates with Sequelize to capture and format database queries.
*   **`emitCacheEvent`**: Emits cache-related events (set, get, delete) to the Lens core.
*   **`watcherEmitter`**: An event emitter for internal communication of query and cache events.

## Installation

```bash
pnpm add @lensjs/watchers
```

## Usage Examples

### Prisma Integration

```typescript
import { PrismaClient } from '@prisma/client';
import { createPrismaHandler } from '@lensjs/watchers/query/prisma';

const prisma = new PrismaClient();

// Initialize the Prisma handler
createPrismaHandler({
  prisma,
  provider: 'sqlite', // or 'postgresql', 'mysql', 'mongodb', etc.
}).then(({ onQuery }) => {
  // 'onQuery' will be called for each captured query
  // You can integrate this with your Lens core setup
  // For example, if Lens core has a method to handle queries:
  // lensCore.handleQuery(queryData);
});

// Your application logic using Prisma
async function main() {
  await prisma.user.findMany();
}

main();
```

### Cache Event Emission

```typescript
import { emitCacheEvent } from '@lensjs/watchers/cache';

// Example of emitting a cache 'write' or 'hit' event
emitCacheEvent({
  action: 'write',
  createdAt: new Date().toISOString(), // createdAt is required by CacheEntry
  data: {
    key: 'user:123',
    value: { id: 123, name: 'Alice' },
  },
});

// Example of emitting a cache 'delete' or 'miss' event
emitCacheEvent({
  action: 'delete',
  createdAt: new Date().toISOString(), // createdAt is required by CacheEntry
  data: {
    key: 'user:456',
  },
});

// Example of emitting a cache 'clear' event
emitCacheEvent({
  action: 'clear',
  createdAt: new Date().toISOString(), // createdAt is required by CacheEntry
  // data property can be omitted or an empty object for 'clear'
});
```