cipher-logger 0.0.1 → 0.1.1

package/.github/workflows/publish.yml

@@ -0,0 +1,60 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Check versions
+        run: |
+          echo "Node: $(node --version)"
+          echo "npm: $(npm --version)"
+          echo "pnpm: $(pnpm --version)"
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build
+        run: pnpm run build
+
+      - name: Publish
+        run: |
+          NAME=$(node -p "require('./package.json').name")
+          VERSION=$(node -p "require('./package.json').version")
+
+          echo "Package: ${NAME}"
+          echo "Version: ${VERSION}"
+
+          if npm view "${NAME}@${VERSION}" version >/dev/null 2>&1; then
+            echo "Skipping publish: ${NAME}@${VERSION} already exists on npm"
+            exit 0
+          fi
+
+          npm publish --access public

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Cipher Logger
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,398 @@
+# Cipher Logger
+
+<p align="center">
+  <strong>See every request. Capture every error. Understand your application.</strong>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/cipher-logger"><img src="https://img.shields.io/npm/v/cipher-logger.svg" alt="npm version"></a>
+  <a href="https://github.com/cipherunits/CipherLogger/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-BSD--3--Clause-blue.svg" alt="license"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg" alt="node version"></a>
+  <a href="https://www.typescriptlang.org"><img src="https://img.shields.io/badge/TypeScript-ready-3178C6.svg" alt="typescript"></a>
+</p>
+
+---
+
+**Cipher Logger** is a lightweight, production-ready HTTP logging library for Node.js. It captures every request in **Express** and **Next.js** applications. You decide exactly which fields appear in each log — required fields are always recorded, optional fields are opt-in.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Express](#express)
+- [Next.js](#nextjs)
+- [Log Schema](#log-schema)
+- [API Reference](#api-reference)
+- [Architecture](#architecture)
+- [Local Development](#local-development)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Features
+
+- **TypeScript-first** — full type coverage across the entire API
+- **Configurable fields** — fine-grained control over optional log fields
+- **Express middleware** — records real `status` and `duration` after the response finishes
+- **Next.js middleware** — drop-in support for `middleware.ts`
+- **Zero heavy dependencies** — only `express` or `next` as optional peer dependencies
+- **Node.js 18+** compatible
+
+---
+
+## Installation
+
+```bash
+npm install cipher-logger
+# or
+pnpm add cipher-logger
+# or
+yarn add cipher-logger
+```
+
+### Peer Dependencies
+
+Install the framework you use:
+
+```bash
+# Express
+npm install express
+
+# Next.js
+npm install next
+```
+
+---
+
+## Quick Start
+
+```typescript
+import { createCipherLogger } from "cipher-logger";
+
+const cipher = createCipherLogger({
+  fields: {
+    ip: true,
+    userAgent: true,
+    query: true,
+  },
+  level: "info",
+});
+```
+
+---
+
+## Configuration
+
+```typescript
+import { createCipherLogger } from "cipher-logger";
+
+const cipher = createCipherLogger({
+  // Optional fields — default: false (disabled)
+  fields: {
+    ip: true,
+    userAgent: true,
+    referer: false,
+    protocol: true,
+    host: true,
+    query: true,
+    requestId: true,
+    metadata: false,
+  },
+
+  // Log level: debug | info | warn | error
+  level: "info",
+
+  // Optional prefix in console output
+  prefix: "api",
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `fields` | `Partial<Record<OptionalRequestField, boolean>>` | all `false` | Optional log fields to include |
+| `level` | `"debug" \| "info" \| "warn" \| "error"` | `"debug"` | Minimum log level |
+| `prefix` | `string` | — | Prefix in console output |
+
+---
+
+## Express
+
+```typescript
+import express from "express";
+import { createCipherLogger } from "cipher-logger";
+
+const app = express();
+
+const cipher = createCipherLogger({
+  fields: {
+    ip: true,
+    userAgent: true,
+    query: true,
+    requestId: true,
+  },
+  level: "info",
+  prefix: "express",
+});
+
+// Mount before your routes
+app.use(cipher.express());
+
+app.get("/users", (req, res) => {
+  res.json({ users: [] });
+});
+
+app.listen(3000, () => {
+  console.log("Server running on http://localhost:3000");
+});
+```
+
+### Sample Output
+
+```text
+[2026-09-01T20:00:00.000Z] [INFO] [express] HTTP Request {
+  id: 'a1b2c3d4-...',
+  type: 'http',
+  timestamp: '2026-09-01T20:00:00.000Z',
+  method: 'GET',
+  path: '/users?page=1',
+  status: 200,
+  duration: 12,
+  ip: '::1',
+  userAgent: 'Mozilla/5.0 ...',
+  query: { page: '1' }
+}
+```
+
+> In Express, `status` and `duration` are recorded after `res.finish` and reflect the actual response.
+
+---
+
+## Next.js
+
+Create `middleware.ts` at the project root (or `src/middleware.ts`):
+
+```typescript
+import { createCipherLogger } from "cipher-logger";
+import type { NextRequest } from "next/server";
+
+const cipher = createCipherLogger({
+  fields: {
+    ip: true,
+    userAgent: true,
+    host: true,
+    query: true,
+  },
+  level: "info",
+});
+
+export function middleware(request: NextRequest) {
+  return cipher.next()(request);
+}
+
+export const config = {
+  matcher: [
+    /*
+     * Match all routes except static files and images
+     */
+    "/((?!_next/static|_next/image|favicon.ico).*)",
+  ],
+};
+```
+
+Or more concisely:
+
+```typescript
+import { createCipherLogger } from "cipher-logger";
+
+const cipher = createCipherLogger({
+  fields: { ip: true, userAgent: true },
+});
+
+export default cipher.next();
+
+export const config = {
+  matcher: ["/api/:path*", "/dashboard/:path*"],
+};
+```
+
+> **Note:** Next.js middleware runs before the route handler, so `status` and `duration` reflect the middleware execution, not the final route response. Route handler wrappers for more accurate logging are planned for future releases.
+
+---
+
+## Log Schema
+
+### Required Fields
+
+Always included in every HTTP log:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | `string` | Unique identifier (UUID) |
+| `type` | `"http"` | Log type |
+| `timestamp` | `string` | ISO 8601 timestamp |
+| `method` | `string` | HTTP method |
+| `path` | `string` | Request path |
+| `status` | `number` | HTTP status code |
+| `duration` | `number` | Duration in milliseconds |
+
+### Optional Fields
+
+Enabled via the `fields` config:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `ip` | `string` | Client IP address |
+| `userAgent` | `string` | User-Agent header |
+| `referer` | `string` | Referer header |
+| `protocol` | `string` | Protocol (`http` / `https`) |
+| `host` | `string` | Host header |
+| `query` | `Record<string, string>` | Query string parameters |
+| `requestId` | `string` | From `x-request-id` header |
+| `metadata` | `Record<string, unknown>` | Custom metadata |
+
+---
+
+## API Reference
+
+### `createCipherLogger(config?)`
+
+Creates a Cipher Logger instance.
+
+```typescript
+const cipher = createCipherLogger(config);
+```
+
+**Methods:**
+
+| Method | Description |
+|--------|-------------|
+| `cipher.logRequest(input)` | Manually log an HTTP request |
+| `cipher.express()` | Returns Express middleware |
+| `cipher.next()` | Returns Next.js middleware |
+
+### `Logger`
+
+Base logging class (independent of HTTP):
+
+```typescript
+import { Logger } from "cipher-logger";
+
+const logger = new Logger({ level: "info", prefix: "app" });
+
+logger.info("Server started");
+logger.warn("Deprecated API used", { route: "/old" });
+logger.error("Unhandled error", { err: "..." });
+logger.debug("Debug info");
+```
+
+### TypeScript Exports
+
+```typescript
+import type {
+  CipherLogger,
+  CipherLoggerConfig,
+  RequestLog,
+  RequestLogInput,
+  OptionalRequestField,
+  LogLevel,
+  LoggerOptions,
+  ExpressMiddleware,
+  NextMiddleware,
+} from "cipher-logger";
+```
+
+---
+
+## Architecture
+
+```
+cipher-logger/
+├── src/
+│   ├── core/           # Core — field config & log building
+│   │   ├── logger.ts
+│   │   ├── types.ts
+│   │   ├── build-request-log.ts
+│   │   └── create-cipher-logger.ts
+│   ├── express/        # Express adapter
+│   │   └── middleware.ts
+│   ├── next/           # Next.js adapter
+│   │   └── middleware.ts
+│   └── index.ts        # Public entry point
+```
+
+```
+┌─────────────────────────────────────────┐
+│                  Core                    │
+│   fields config → buildRequestLog        │
+└──────────────────┬──────────────────────┘
+                   │
+         ┌─────────┴─────────┐
+         ▼                   ▼
+   ┌───────────┐       ┌───────────┐
+   │  Express  │       │  Next.js  │
+   │ middleware│       │ middleware│
+   └───────────┘       └───────────┘
+```
+
+---
+
+## Local Development
+
+```bash
+git clone https://github.com/cipherunits/CipherLogger.git
+cd CipherLogger
+pnpm install
+pnpm run build
+```
+
+---
+
+## Contributing
+
+Contributions are welcome and appreciated.
+
+### Report a Bug or Request a Feature
+
+1. Check [Issues](https://github.com/cipherunits/CipherLogger/issues) first
+2. If no existing issue matches, open a new one with a clear description
+
+### Submit a Pull Request
+
+1. Fork the repository
+2. Create a branch: `git checkout -b feature/my-feature`
+3. Commit your changes: `git commit -m "feat: add something useful"`
+4. Push the branch: `git push origin feature/my-feature`
+5. Open a Pull Request
+
+### Guidelines
+
+- Use [Conventional Commits](https://www.conventionalcommits.org/) for commit messages
+- Run `pnpm run build` before submitting a PR
+- Keep changes focused and scoped
+- Update the README for any API changes
+
+### Contact
+
+- **GitHub Issues:** [cipherunits/CipherLogger/issues](https://github.com/cipherunits/CipherLogger/issues)
+- **Organization:** [CipherUnits](https://github.com/cipherunits)
+
+---
+
+## License
+
+This project is licensed under the [BSD 3-Clause License](LICENSE).
+
+```
+Copyright (c) 2026, Cipher Logger
+```
+
+Free to use, modify, and distribute — provided the copyright notice and license terms are preserved. See [LICENSE](LICENSE) for full details.
+
+---
+
+<p align="center">
+  Built with ❤️ by <a href="https://github.com/cipherunits">CipherUnits</a>
+</p>

package/dist/index.d.mts

@@ -0,0 +1,77 @@
+import { Request, Response, NextFunction } from 'express';
+import { NextRequest, NextResponse } from 'next/server';
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+type LogMeta = Record<string, unknown>;
+interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+}
+declare class Logger {
+    private readonly level;
+    private readonly prefix?;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private format;
+    private log;
+    info(message: string, meta?: LogMeta): void;
+    warn(message: string, meta?: LogMeta): void;
+    error(message: string, meta?: LogMeta): void;
+    debug(message: string, meta?: LogMeta): void;
+}
+
+declare const OPTIONAL_REQUEST_FIELDS: readonly ["ip", "userAgent", "referer", "protocol", "host", "query", "requestId", "metadata"];
+type OptionalRequestField = (typeof OPTIONAL_REQUEST_FIELDS)[number];
+type RequestLog = {
+    id: string;
+    type: "http";
+    timestamp: string;
+    method: string;
+    path: string;
+    status: number;
+    duration: number;
+    ip?: string;
+    userAgent?: string;
+    referer?: string;
+    protocol?: string;
+    host?: string;
+    query?: Record<string, string>;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+};
+type RequestLogInput = {
+    method: string;
+    path: string;
+    status: number;
+    duration: number;
+    ip?: string;
+    userAgent?: string;
+    referer?: string;
+    protocol?: string;
+    host?: string;
+    query?: Record<string, string>;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+};
+type CipherLoggerConfig = {
+    fields?: Partial<Record<OptionalRequestField, boolean>>;
+    level?: LogLevel;
+    prefix?: string;
+};
+
+type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+declare function createExpressMiddleware(cipher: CipherLogger): ExpressMiddleware;
+
+type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextResponse>;
+declare function createNextMiddleware(cipher: CipherLogger): NextMiddleware;
+
+interface CipherLogger {
+    logRequest(input: RequestLogInput): RequestLog;
+    express(): ExpressMiddleware;
+    next(): NextMiddleware;
+}
+declare function createCipherLogger(config?: CipherLoggerConfig): CipherLogger;
+
+declare const logger: Logger;
+
+export { type CipherLogger, type CipherLoggerConfig, type ExpressMiddleware, type LogLevel, type LogMeta, Logger, type LoggerOptions, type NextMiddleware, type OptionalRequestField, type RequestLog, type RequestLogInput, createCipherLogger, createExpressMiddleware, createNextMiddleware, logger, type RequestLog as request };

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { Request, Response, NextFunction } from 'express';
+import { NextRequest, NextResponse } from 'next/server';
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+type LogMeta = Record<string, unknown>;
+interface LoggerOptions {
+    level?: LogLevel;
+    prefix?: string;
+}
+declare class Logger {
+    private readonly level;
+    private readonly prefix?;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private format;
+    private log;
+    info(message: string, meta?: LogMeta): void;
+    warn(message: string, meta?: LogMeta): void;
+    error(message: string, meta?: LogMeta): void;
+    debug(message: string, meta?: LogMeta): void;
+}
+
+declare const OPTIONAL_REQUEST_FIELDS: readonly ["ip", "userAgent", "referer", "protocol", "host", "query", "requestId", "metadata"];
+type OptionalRequestField = (typeof OPTIONAL_REQUEST_FIELDS)[number];
+type RequestLog = {
+    id: string;
+    type: "http";
+    timestamp: string;
+    method: string;
+    path: string;
+    status: number;
+    duration: number;
+    ip?: string;
+    userAgent?: string;
+    referer?: string;
+    protocol?: string;
+    host?: string;
+    query?: Record<string, string>;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+};
+type RequestLogInput = {
+    method: string;
+    path: string;
+    status: number;
+    duration: number;
+    ip?: string;
+    userAgent?: string;
+    referer?: string;
+    protocol?: string;
+    host?: string;
+    query?: Record<string, string>;
+    requestId?: string;
+    metadata?: Record<string, unknown>;
+};
+type CipherLoggerConfig = {
+    fields?: Partial<Record<OptionalRequestField, boolean>>;
+    level?: LogLevel;
+    prefix?: string;
+};
+
+type ExpressMiddleware = (req: Request, res: Response, next: NextFunction) => void;
+declare function createExpressMiddleware(cipher: CipherLogger): ExpressMiddleware;
+
+type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextResponse>;
+declare function createNextMiddleware(cipher: CipherLogger): NextMiddleware;
+
+interface CipherLogger {
+    logRequest(input: RequestLogInput): RequestLog;
+    express(): ExpressMiddleware;
+    next(): NextMiddleware;
+}
+declare function createCipherLogger(config?: CipherLoggerConfig): CipherLogger;
+
+declare const logger: Logger;
+
+export { type CipherLogger, type CipherLoggerConfig, type ExpressMiddleware, type LogLevel, type LogMeta, Logger, type LoggerOptions, type NextMiddleware, type OptionalRequestField, type RequestLog, type RequestLogInput, createCipherLogger, createExpressMiddleware, createNextMiddleware, logger, type RequestLog as request };

package/dist/index.js

@@ -0,0 +1,259 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Logger: () => Logger,
+  createCipherLogger: () => createCipherLogger,
+  createExpressMiddleware: () => createExpressMiddleware,
+  createNextMiddleware: () => createNextMiddleware,
+  logger: () => logger
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/logger.ts
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  prefix;
+  constructor(options = {}) {
+    this.level = options.level ?? "debug";
+    this.prefix = options.prefix;
+  }
+  shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.level];
+  }
+  format(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = this.prefix ? ` [${this.prefix}]` : "";
+    return `[${timestamp}] [${level.toUpperCase()}]${prefix} ${message}`;
+  }
+  log(level, message, meta) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const output = this.format(level, message);
+    switch (level) {
+      case "error":
+        meta ? console.error(output, meta) : console.error(output);
+        break;
+      case "warn":
+        meta ? console.warn(output, meta) : console.warn(output);
+        break;
+      case "debug":
+        meta ? console.debug(output, meta) : console.debug(output);
+        break;
+      case "info":
+        meta ? console.info(output, meta) : console.info(output);
+        break;
+    }
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+};
+
+// src/core/build-request-log.ts
+var import_node_crypto = require("crypto");
+
+// src/core/types.ts
+var OPTIONAL_REQUEST_FIELDS = [
+  "ip",
+  "userAgent",
+  "referer",
+  "protocol",
+  "host",
+  "query",
+  "requestId",
+  "metadata"
+];
+
+// src/core/build-request-log.ts
+function resolveFieldConfig(fields) {
+  const resolved = {};
+  for (const field of OPTIONAL_REQUEST_FIELDS) {
+    resolved[field] = fields?.[field] ?? false;
+  }
+  return resolved;
+}
+function buildRequestLog(fields, input) {
+  const log = {
+    id: (0, import_node_crypto.randomUUID)(),
+    type: "http",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: input.method,
+    path: input.path,
+    status: input.status,
+    duration: input.duration
+  };
+  for (const field of OPTIONAL_REQUEST_FIELDS) {
+    if (!fields[field] || input[field] === void 0) {
+      continue;
+    }
+    switch (field) {
+      case "ip":
+        log.ip = input.ip;
+        break;
+      case "userAgent":
+        log.userAgent = input.userAgent;
+        break;
+      case "referer":
+        log.referer = input.referer;
+        break;
+      case "protocol":
+        log.protocol = input.protocol;
+        break;
+      case "host":
+        log.host = input.host;
+        break;
+      case "query":
+        log.query = input.query;
+        break;
+      case "requestId":
+        log.requestId = input.requestId;
+        break;
+      case "metadata":
+        log.metadata = input.metadata;
+        break;
+    }
+  }
+  return log;
+}
+
+// src/express/middleware.ts
+function parseQuery(query) {
+  const result = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    result[key] = typeof value === "string" ? value : Array.isArray(value) ? String(value[0] ?? "") : String(value);
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function getHeader(req, name) {
+  const value = req.headers[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0] : value;
+}
+function createExpressMiddleware(cipher) {
+  return (req, res, next) => {
+    const start = Date.now();
+    res.on("finish", () => {
+      cipher.logRequest({
+        method: req.method,
+        path: req.originalUrl || req.url,
+        status: res.statusCode,
+        duration: Date.now() - start,
+        ip: req.ip || req.socket.remoteAddress,
+        userAgent: getHeader(req, "user-agent"),
+        referer: getHeader(req, "referer"),
+        protocol: req.protocol,
+        host: getHeader(req, "host"),
+        query: parseQuery(req.query),
+        requestId: getHeader(req, "x-request-id")
+      });
+    });
+    next();
+  };
+}
+
+// src/next/middleware.ts
+var import_server = require("next/server");
+function getHeader2(request, name) {
+  return request.headers.get(name) ?? void 0;
+}
+function parseQuery2(request) {
+  const result = {};
+  for (const [key, value] of request.nextUrl.searchParams.entries()) {
+    result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function createNextMiddleware(cipher) {
+  return (request) => {
+    const start = Date.now();
+    const response = import_server.NextResponse.next();
+    cipher.logRequest({
+      method: request.method,
+      path: request.nextUrl.pathname + request.nextUrl.search,
+      status: response.status,
+      duration: Date.now() - start,
+      ip: getHeader2(request, "x-forwarded-for")?.split(",")[0]?.trim() || getHeader2(request, "x-real-ip"),
+      userAgent: getHeader2(request, "user-agent"),
+      referer: getHeader2(request, "referer"),
+      protocol: request.nextUrl.protocol.replace(":", ""),
+      host: getHeader2(request, "host"),
+      query: parseQuery2(request),
+      requestId: getHeader2(request, "x-request-id")
+    });
+    return response;
+  };
+}
+
+// src/core/create-cipher-logger.ts
+function createCipherLogger(config = {}) {
+  const fields = resolveFieldConfig(config.fields);
+  const logger2 = new Logger({
+    level: config.level,
+    prefix: config.prefix
+  });
+  const cipherLogger = {
+    logRequest(input) {
+      const log = buildRequestLog(fields, input);
+      logger2.info("HTTP Request", log);
+      return log;
+    },
+    express() {
+      return createExpressMiddleware(cipherLogger);
+    },
+    next() {
+      return createNextMiddleware(cipherLogger);
+    }
+  };
+  return cipherLogger;
+}
+
+// src/index.ts
+var logger = new Logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  createCipherLogger,
+  createExpressMiddleware,
+  createNextMiddleware,
+  logger
+});

package/dist/index.mjs

@@ -0,0 +1,228 @@
+// src/core/logger.ts
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  level;
+  prefix;
+  constructor(options = {}) {
+    this.level = options.level ?? "debug";
+    this.prefix = options.prefix;
+  }
+  shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.level];
+  }
+  format(level, message) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = this.prefix ? ` [${this.prefix}]` : "";
+    return `[${timestamp}] [${level.toUpperCase()}]${prefix} ${message}`;
+  }
+  log(level, message, meta) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const output = this.format(level, message);
+    switch (level) {
+      case "error":
+        meta ? console.error(output, meta) : console.error(output);
+        break;
+      case "warn":
+        meta ? console.warn(output, meta) : console.warn(output);
+        break;
+      case "debug":
+        meta ? console.debug(output, meta) : console.debug(output);
+        break;
+      case "info":
+        meta ? console.info(output, meta) : console.info(output);
+        break;
+    }
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+};
+
+// src/core/build-request-log.ts
+import { randomUUID } from "crypto";
+
+// src/core/types.ts
+var OPTIONAL_REQUEST_FIELDS = [
+  "ip",
+  "userAgent",
+  "referer",
+  "protocol",
+  "host",
+  "query",
+  "requestId",
+  "metadata"
+];
+
+// src/core/build-request-log.ts
+function resolveFieldConfig(fields) {
+  const resolved = {};
+  for (const field of OPTIONAL_REQUEST_FIELDS) {
+    resolved[field] = fields?.[field] ?? false;
+  }
+  return resolved;
+}
+function buildRequestLog(fields, input) {
+  const log = {
+    id: randomUUID(),
+    type: "http",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    method: input.method,
+    path: input.path,
+    status: input.status,
+    duration: input.duration
+  };
+  for (const field of OPTIONAL_REQUEST_FIELDS) {
+    if (!fields[field] || input[field] === void 0) {
+      continue;
+    }
+    switch (field) {
+      case "ip":
+        log.ip = input.ip;
+        break;
+      case "userAgent":
+        log.userAgent = input.userAgent;
+        break;
+      case "referer":
+        log.referer = input.referer;
+        break;
+      case "protocol":
+        log.protocol = input.protocol;
+        break;
+      case "host":
+        log.host = input.host;
+        break;
+      case "query":
+        log.query = input.query;
+        break;
+      case "requestId":
+        log.requestId = input.requestId;
+        break;
+      case "metadata":
+        log.metadata = input.metadata;
+        break;
+    }
+  }
+  return log;
+}
+
+// src/express/middleware.ts
+function parseQuery(query) {
+  const result = {};
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    result[key] = typeof value === "string" ? value : Array.isArray(value) ? String(value[0] ?? "") : String(value);
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function getHeader(req, name) {
+  const value = req.headers[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0] : value;
+}
+function createExpressMiddleware(cipher) {
+  return (req, res, next) => {
+    const start = Date.now();
+    res.on("finish", () => {
+      cipher.logRequest({
+        method: req.method,
+        path: req.originalUrl || req.url,
+        status: res.statusCode,
+        duration: Date.now() - start,
+        ip: req.ip || req.socket.remoteAddress,
+        userAgent: getHeader(req, "user-agent"),
+        referer: getHeader(req, "referer"),
+        protocol: req.protocol,
+        host: getHeader(req, "host"),
+        query: parseQuery(req.query),
+        requestId: getHeader(req, "x-request-id")
+      });
+    });
+    next();
+  };
+}
+
+// src/next/middleware.ts
+import { NextResponse } from "next/server";
+function getHeader2(request, name) {
+  return request.headers.get(name) ?? void 0;
+}
+function parseQuery2(request) {
+  const result = {};
+  for (const [key, value] of request.nextUrl.searchParams.entries()) {
+    result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function createNextMiddleware(cipher) {
+  return (request) => {
+    const start = Date.now();
+    const response = NextResponse.next();
+    cipher.logRequest({
+      method: request.method,
+      path: request.nextUrl.pathname + request.nextUrl.search,
+      status: response.status,
+      duration: Date.now() - start,
+      ip: getHeader2(request, "x-forwarded-for")?.split(",")[0]?.trim() || getHeader2(request, "x-real-ip"),
+      userAgent: getHeader2(request, "user-agent"),
+      referer: getHeader2(request, "referer"),
+      protocol: request.nextUrl.protocol.replace(":", ""),
+      host: getHeader2(request, "host"),
+      query: parseQuery2(request),
+      requestId: getHeader2(request, "x-request-id")
+    });
+    return response;
+  };
+}
+
+// src/core/create-cipher-logger.ts
+function createCipherLogger(config = {}) {
+  const fields = resolveFieldConfig(config.fields);
+  const logger2 = new Logger({
+    level: config.level,
+    prefix: config.prefix
+  });
+  const cipherLogger = {
+    logRequest(input) {
+      const log = buildRequestLog(fields, input);
+      logger2.info("HTTP Request", log);
+      return log;
+    },
+    express() {
+      return createExpressMiddleware(cipherLogger);
+    },
+    next() {
+      return createNextMiddleware(cipherLogger);
+    }
+  };
+  return cipherLogger;
+}
+
+// src/index.ts
+var logger = new Logger();
+export {
+  Logger,
+  createCipherLogger,
+  createExpressMiddleware,
+  createNextMiddleware,
+  logger
+};

package/package.json

@@ -1,12 +1,75 @@
 {
   "name": "cipher-logger",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
+  "version": "0.1.1",
+  "description": "See every request. Capture every error. Understand your application.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsup",
+    "prepublishOnly": "npm run build"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC"
-}
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cipherunits/CipherLogger.git"
+  },
+  "author": "CipherUnits",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/cipherunits/CipherLogger/issues"
+  },
+  "homepage": "https://github.com/cipherunits/CipherLogger#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "logger",
+    "logging",
+    "log",
+    "logging-library",
+    "node-logger",
+    "nodejs-logger",
+    "javascript-logger",
+    "typescript-logger",
+    "http-logger",
+    "request-logger",
+    "error-logger",
+    "request-logging",
+    "error-logging",
+    "monitoring",
+    "observability",
+    "nextjs",
+    "nextjs-logger",
+    "nextjs-middleware",
+    "express",
+    "express-logger",
+    "cli",
+    "dashboard",
+    "cipherlogger",
+    "cipherunits"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs",
+  "peerDependencies": {
+    "express": ">=4",
+    "next": ">=13"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.3",
+    "@types/node": "^26.1.2",
+    "express": "^5.1.0",
+    "next": "^15.5.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  }
+}