mohen 1.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x, 22.x]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: 9
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Check TypeScript types
+        run: pnpm exec tsc --noEmit
+
+      - name: Run tests
+        run: pnpm test

package/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+        with:
+          version: 9
+
+      - name: Install dependencies
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Run tests
+        run: pnpm test
+
+      - name: Publish to npm
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,198 @@
+# mohen 墨痕
+
+A simple, unified request/response logger for Express and tRPC that writes to a single file with JSON lines format.
+
+## Features
+
+- Single file logging for both Express and tRPC
+- JSON lines format (one JSON object per line)
+- SSE streaming support with chunk aggregation
+- Arbitrary metadata attachment
+- Automatic field redaction (passwords, tokens, etc.)
+- File size management with automatic truncation
+
+## Installation
+
+```bash
+npm install mohen
+# or
+pnpm add mohen
+```
+
+## Quick Start
+
+```typescript
+import express from 'express';
+import { createLogger } from 'mohen';
+
+const logger = createLogger('./logs/app.log');
+
+const app = express();
+app.use(express.json());
+app.use(logger.express());
+
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'ok' });
+});
+
+app.listen(3000);
+```
+
+That's it. All requests and responses are now logged to `./logs/app.log`.
+
+## Usage
+
+### Express
+
+```typescript
+import { createLogger, attachMetadata } from 'mohen';
+
+const logger = createLogger('./logs/app.log', {
+  maxSizeBytes: 10 * 1024 * 1024, // 10MB max, then truncate to 25%
+  redact: ['password', 'token', 'secret'],
+});
+
+app.use(logger.express());
+
+// Attach custom metadata to any request
+app.get('/api/users/:id', (req, res) => {
+  attachMetadata(req, {
+    userId: req.params.id,
+    source: 'user-service',
+    cacheHit: false,
+  });
+
+  res.json({ id: req.params.id, name: 'John Doe' });
+});
+```
+
+### tRPC
+
+```typescript
+import { initTRPC } from '@trpc/server';
+import { createLogger, attachTrpcMetadata } from 'mohen';
+
+interface Context {
+  logMetadata?: Record<string, unknown>;
+}
+
+const logger = createLogger('./logs/app.log');
+const t = initTRPC.context<Context>().create();
+
+const loggedProcedure = t.procedure.use(logger.trpc<Context>());
+
+const appRouter = t.router({
+  getUser: loggedProcedure
+    .input((val: unknown) => val as { id: string })
+    .query(({ input, ctx }) => {
+      // Attach custom metadata
+      attachTrpcMetadata(ctx, {
+        userId: input.id,
+        source: 'user-service',
+      });
+
+      return { id: input.id, name: 'John Doe' };
+    }),
+});
+```
+
+### SSE Streaming
+
+SSE responses are automatically detected and all chunks are aggregated into a single log entry:
+
+```typescript
+app.get('/api/stream', (req, res) => {
+  attachMetadata(req, { streamType: 'events' });
+
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.write(`data: ${JSON.stringify({ count: 1 })}\n\n`);
+  res.write(`data: ${JSON.stringify({ count: 2 })}\n\n`);
+  res.end();
+});
+```
+
+Log output:
+```json
+{
+  "type": "http",
+  "path": "/api/stream",
+  "response": {
+    "streaming": true,
+    "chunks": [{"count": 1}, {"count": 2}]
+  },
+  "metadata": {"streamType": "events"}
+}
+```
+
+## Configuration Options
+
+```typescript
+createLogger(filePath, {
+  maxSizeBytes: 10 * 1024 * 1024, // Max file size before truncation (default: 10MB)
+  includeHeaders: false,          // Log request headers (default: false)
+  redact: ['password', 'token'],  // Fields to redact (default: password, token, authorization, cookie)
+});
+```
+
+## Log Format
+
+Each line is a JSON object with the following structure:
+
+```json
+{
+  "timestamp": "2024-01-15T10:30:00.000Z",
+  "requestId": "m1abc123-xyz789",
+  "type": "http",
+  "method": "POST",
+  "path": "/api/users",
+  "statusCode": 200,
+  "duration": 45,
+  "request": {
+    "body": {"name": "John", "password": "[REDACTED]"},
+    "query": {}
+  },
+  "response": {
+    "body": {"id": 1, "name": "John"},
+    "streaming": false
+  },
+  "metadata": {
+    "userId": "123",
+    "source": "signup-flow"
+  }
+}
+```
+
+## File Size Management
+
+When the log file exceeds `maxSizeBytes`, the oldest 75% of log entries are removed, keeping the most recent 25%. This happens automatically before each write.
+
+## API Reference
+
+### `createLogger(filePath, options?)`
+
+Creates a logger instance.
+
+Returns:
+- `express()` - Express middleware function
+- `trpc<TContext>()` - tRPC middleware function
+- `write(entry)` - Direct write access for custom logging
+
+### `attachMetadata(req, metadata)`
+
+Attach arbitrary metadata to an Express request's log entry.
+
+```typescript
+attachMetadata(req, { userId: '123', feature: 'checkout' });
+```
+
+### `attachTrpcMetadata(ctx, metadata)`
+
+Attach arbitrary metadata to a tRPC procedure's log entry.
+
+```typescript
+attachTrpcMetadata(ctx, { userId: '123', feature: 'checkout' });
+```
+
+## License
+
+MIT

package/dist/logger.d.ts

@@ -0,0 +1,72 @@
+import type { Request, Response, NextFunction } from 'express';
+interface LogEntry {
+    timestamp: string;
+    requestId: string;
+    type: 'http' | 'trpc';
+    method: string;
+    path: string;
+    statusCode?: number;
+    duration: number;
+    request?: {
+        body?: unknown;
+        query?: unknown;
+        headers?: Record<string, string>;
+    };
+    response?: {
+        body?: unknown;
+        streaming?: boolean;
+        chunks?: unknown[];
+    };
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface LoggerOptions {
+    maxSizeBytes?: number;
+    includeHeaders?: boolean;
+    redact?: string[];
+}
+declare global {
+    namespace Express {
+        interface Request {
+            logMetadata?: Record<string, unknown>;
+        }
+    }
+}
+export declare function createLogger(filePath: string, options?: LoggerOptions): {
+    /** Express middleware - use with app.use() */
+    express: () => (req: Request, res: Response, next: NextFunction) => void;
+    /** tRPC middleware - use with t.procedure.use() */
+    trpc: <TContext extends Record<string, unknown> = Record<string, unknown>>() => (opts: {
+        path: string;
+        type: "query" | "mutation" | "subscription";
+        input: unknown;
+        ctx: TContext & {
+            logMetadata?: Record<string, unknown>;
+        };
+        next: () => Promise<{
+            ok: boolean;
+            data?: unknown;
+            error?: Error;
+        }>;
+    }) => Promise<{
+        ok: boolean;
+        data?: unknown;
+        error?: Error;
+    }>;
+    /** Direct write access for custom logging */
+    write: (entry: Partial<LogEntry>) => void;
+};
+/**
+ * Attach metadata to the current request log entry (Express)
+ */
+export declare function attachMetadata(req: Request, metadata: Record<string, unknown>): void;
+/**
+ * Attach metadata to the current request log entry (tRPC)
+ */
+export declare function attachTrpcMetadata<TContext extends {
+    logMetadata?: Record<string, unknown>;
+}>(ctx: TContext, metadata: Record<string, unknown>): void;
+export default createLogger;