@visulima/pail 4.0.0-alpha.10 → 4.0.0-alpha.12

package/dist/middleware/express.d.ts

@@ -1,86 +1,88 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * An Express-like request object with the pail logger attached.
- * Use this to type your route handlers when accessing `req.log`.
- * @example
- * ```typescript
- * import type { PailRequest } from "@visulima/pail/middleware/express";
- *
- * app.get("/api/users", (req: PailRequest, res) => {
- *   req.log?.set({ user: { id: 1 } });
- * });
- * ```
- */
+* An Express-like request object with the pail logger attached.
+* Use this to type your route handlers when accessing `req.log`.
+* @example
+* ```typescript
+* import type { PailRequest } from "@visulima/pail/middleware/express";
+*
+* app.get("/api/users", (req: PailRequest, res) => {
+*   req.log?.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailRequest {
-    [key: string]: unknown;
-    headers: Record<string, string | string[] | undefined>;
-    /**
-     * The request-scoped WideEvent logger, attached by pail middleware.
-     * Only present for non-excluded routes.
-     */
-    log?: WideEvent;
-    method: string;
-    originalUrl?: string;
-    path: string;
+  [key: string]: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  /**
+  * The request-scoped WideEvent logger, attached by pail middleware.
+  * Only present for non-excluded routes.
+  */
+  log?: WideEvent;
+  method: string;
+  originalUrl?: string;
+  path: string;
 }
 /**
- * An Express-like response object.
- */
+* An Express-like response object.
+*/
 interface PailResponse {
-    [key: string]: unknown;
-    on: (event: string, listener: () => void) => void;
-    statusCode: number;
+  [key: string]: unknown;
+  on: (event: string, listener: () => void) => void;
+  statusCode: number;
 }
 /**
- * Express-compatible next function.
- */
+* Express-compatible next function.
+*/
 type PailNextFunction = (error?: unknown) => void;
 /**
- * The Express middleware function signature returned by `pailMiddleware()`.
- */
+* The Express middleware function signature returned by `pailMiddleware()`.
+*/
 type PailExpressMiddleware = (request: PailRequest, response: PailResponse, next: PailNextFunction) => void;
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handled by the pail Express middleware.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the middleware context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail Express middleware.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the middleware context
+*/
 declare const useLogger: () => WideEvent;
 /**
- * Configuration options for the Express pail middleware.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Express pail middleware.
+* @template T - Custom logger type names from the pail instance
+*/
 type ExpressMiddlewareOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Create Express middleware that attaches a WideEvent logger to each request.
- *
- * The logger is available via:
- * - `req.log` on the request object
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted when the response finishes.
- * @param options Middleware configuration
- * @returns Express middleware function
- * @example
- * ```typescript
- * import express from "express";
- * import { createPail } from "@visulima/pail";
- * import { pailMiddleware, useLogger } from "@visulima/pail/middleware/express";
- *
- * const app = express();
- * const logger = createPail();
- *
- * app.use(pailMiddleware({ pail: logger }));
- *
- * app.get("/api/users", (req, res) => {
- *   req.log.set({ user: { id: 1 } });
- *   // or: useLogger().set({ user: { id: 1 } });
- *   res.json({ ok: true });
- * });
- * ```
- */
-export declare const pailMiddleware: <T extends string = string>(options: ExpressMiddlewareOptions<T>) => PailExpressMiddleware;
-export { useLogger };
-export type { ExpressMiddlewareOptions, PailExpressMiddleware, PailNextFunction, PailRequest, PailResponse };
-export type { WideEvent } from "../wide-event.d.ts";
+* Create Express middleware that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `req.log` on the request object
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted when the response finishes.
+* @param options Middleware configuration
+* @returns Express middleware function
+* @example
+* ```typescript
+* import express from "express";
+* import { createPail } from "@visulima/pail";
+* import { pailMiddleware, useLogger } from "@visulima/pail/middleware/express";
+*
+* const app = express();
+* const logger = createPail();
+*
+* app.use(pailMiddleware({ pail: logger }));
+*
+* app.get("/api/users", (req, res) => {
+*   req.log.set({ user: { id: 1 } });
+*   // or: useLogger().set({ user: { id: 1 } });
+*   res.json({ ok: true });
+* });
+* ```
+*/
+declare const pailMiddleware: <T extends string = string>(options: ExpressMiddlewareOptions<T>) => PailExpressMiddleware;
+export { type ExpressMiddlewareOptions, type PailExpressMiddleware, type PailNextFunction, type PailRequest, type PailResponse, type WideEvent, pailMiddleware, useLogger };

package/dist/middleware/express.js

@@ -5,7 +5,7 @@ const loggerStorage = createLoggerStorage("Express middleware context. Make sure
 const useLogger = () => loggerStorage.useLogger();
 const pailMiddleware = (options) => (request, response, next) => {
   const requestId = request.headers["x-request-id"] ?? crypto.randomUUID();
-  const path = request.originalUrl;
+  const path = request.originalUrl ?? request.url ?? "/";
   const safeHeaders = extractSafeNodeHeaders(request.headers);
   const { finish, logger, skipped } = createMiddlewareLogger(options, {
     headers: safeHeaders,

package/dist/middleware/fastify.d.ts

@@ -1,81 +1,83 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A Fastify-like request object with the pail logger attached.
- * Use this to type your route handlers when accessing `request.log`.
- * @example
- * ```typescript
- * import type { PailFastifyRequest } from "@visulima/pail/middleware/fastify";
- *
- * app.get("/api/users", async (request: PailFastifyRequest, reply) => {
- *   request.log?.set({ user: { id: 1 } });
- * });
- * ```
- */
+* A Fastify-like request object with the pail logger attached.
+* Use this to type your route handlers when accessing `request.log`.
+* @example
+* ```typescript
+* import type { PailFastifyRequest } from "@visulima/pail/middleware/fastify";
+*
+* app.get("/api/users", async (request: PailFastifyRequest, reply) => {
+*   request.log?.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailFastifyRequest {
-    [key: string]: unknown;
-    headers: Record<string, string | string[] | undefined>;
-    /**
-     * The request-scoped WideEvent logger, attached by pail plugin.
-     * Only present for non-excluded routes.
-     */
-    log?: WideEvent;
-    method: string;
-    url: string;
+  [key: string]: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  /**
+  * The request-scoped WideEvent logger, attached by pail plugin.
+  * Only present for non-excluded routes.
+  */
+  log?: WideEvent;
+  method: string;
+  url: string;
 }
 /**
- * A Fastify-like reply object.
- */
+* A Fastify-like reply object.
+*/
 interface PailFastifyReply {
-    [key: string]: unknown;
-    statusCode: number;
+  [key: string]: unknown;
+  statusCode: number;
 }
 /**
- * A Fastify-like instance that supports the hook registration API.
- */
+* A Fastify-like instance that supports the hook registration API.
+*/
 interface PailFastifyInstance {
-    addHook: ((name: "onError", hook: (request: PailFastifyRequest, reply: PailFastifyReply, error: Error) => Promise<void>) => void) & ((name: "onRequest", hook: (request: PailFastifyRequest, reply: PailFastifyReply, done: () => void) => void) => void) & ((name: "onResponse", hook: (request: PailFastifyRequest, reply: PailFastifyReply) => Promise<void>) => void);
+  addHook: ((name: "onError", hook: (request: PailFastifyRequest, reply: PailFastifyReply, error: Error) => Promise<void>) => void) & ((name: "onRequest", hook: (request: PailFastifyRequest, reply: PailFastifyReply, done: () => void) => void) => void) & ((name: "onResponse", hook: (request: PailFastifyRequest, reply: PailFastifyReply) => Promise<void>) => void);
 }
 /**
- * Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
- * Must be called within a request handled by the pail Fastify plugin.
- * @returns The request-scoped WideEvent logger
- * @throws Error if called outside of the plugin context
- */
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a request handled by the pail Fastify plugin.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of the plugin context
+*/
 declare const useLogger: () => WideEvent;
 /**
- * Configuration options for the Fastify pail plugin.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Fastify pail plugin.
+* @template T - Custom logger type names from the pail instance
+*/
 type FastifyPluginOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Register pail wide event logging as a Fastify plugin.
- *
- * Attaches a WideEvent logger to each request, accessible via:
- * - `request.log` on the Fastify request object
- * - `useLogger()` from anywhere in the async call stack
- *
- * The wide event is automatically emitted on response or error.
- * @param fastify The Fastify instance
- * @param options Plugin configuration
- * @example
- * ```typescript
- * import Fastify from "fastify";
- * import { createPail } from "@visulima/pail";
- * import { pailPlugin, useLogger } from "@visulima/pail/middleware/fastify";
- *
- * const app = Fastify();
- * const logger = createPail();
- *
- * pailPlugin(app, { pail: logger });
- *
- * app.get("/api/users", async (request, reply) => {
- *   request.log.set({ user: { id: 1 } });
- *   return { ok: true };
- * });
- * ```
- */
-export declare const pailPlugin: <T extends string = string>(fastify: PailFastifyInstance, options: FastifyPluginOptions<T>) => void;
-export { useLogger };
-export type { FastifyPluginOptions, PailFastifyInstance, PailFastifyReply, PailFastifyRequest };
-export type { WideEvent } from "../wide-event.d.ts";
+* Register pail wide event logging as a Fastify plugin.
+*
+* Attaches a WideEvent logger to each request, accessible via:
+* - `request.log` on the Fastify request object
+* - `useLogger()` from anywhere in the async call stack
+*
+* The wide event is automatically emitted on response or error.
+* @param fastify The Fastify instance
+* @param options Plugin configuration
+* @example
+* ```typescript
+* import Fastify from "fastify";
+* import { createPail } from "@visulima/pail";
+* import { pailPlugin, useLogger } from "@visulima/pail/middleware/fastify";
+*
+* const app = Fastify();
+* const logger = createPail();
+*
+* pailPlugin(app, { pail: logger });
+*
+* app.get("/api/users", async (request, reply) => {
+*   request.log.set({ user: { id: 1 } });
+*   return { ok: true };
+* });
+* ```
+*/
+declare const pailPlugin: <T extends string = string>(fastify: PailFastifyInstance, options: FastifyPluginOptions<T>) => void;
+export { type FastifyPluginOptions, type PailFastifyInstance, type PailFastifyReply, type PailFastifyRequest, type WideEvent, pailPlugin, useLogger };

package/dist/middleware/fastify.js

@@ -25,7 +25,7 @@ const pailPlugin = (fastify, options) => {
       done();
     });
   });
-  fastify.addHook("onResponse", (request, reply) => {
+  fastify.addHook("onResponse", async (request, reply) => {
     const state = requestState.get(request);
     if (!state || emitted.has(request)) {
       return;
@@ -33,7 +33,7 @@ const pailPlugin = (fastify, options) => {
     emitted.add(request);
     state.finish({ status: reply.statusCode });
   });
-  fastify.addHook("onError", (request, _reply, error) => {
+  fastify.addHook("onError", async (request, _reply, error) => {
     const state = requestState.get(request);
     if (!state || emitted.has(request)) {
       return;

package/dist/middleware/hono.d.ts

@@ -1,85 +1,87 @@
-import type { WideEvent } from "../wide-event.d.ts";
-import type { PailMiddlewareOptions } from "./shared/create-middleware-logger.d.ts";
+import { W as WideEvent } from "../packem_shared/wide-event.d-B-t8ZnhI.js";
+import { P as PailMiddlewareOptions } from "../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import 'safe-stable-stringify';
+import "../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
 /**
- * A Hono-like context object with access to the pail logger.
- *
- * Use `c.get("log")` or `useLogger(c)` to access the WideEvent logger.
- * @example
- * ```typescript
- * import type { PailHonoContext } from "@visulima/pail/middleware/hono";
- *
- * app.get("/api/users", (c: PailHonoContext) => {
- *   const log = c.get("log");
- *   log.set({ user: { id: 1 } });
- * });
- * ```
- */
+* A Hono-like context object with access to the pail logger.
+*
+* Use `c.get("log")` or `useLogger(c)` to access the WideEvent logger.
+* @example
+* ```typescript
+* import type { PailHonoContext } from "@visulima/pail/middleware/hono";
+*
+* app.get("/api/users", (c: PailHonoContext) => {
+*   const log = c.get("log");
+*   log.set({ user: { id: 1 } });
+* });
+* ```
+*/
 interface PailHonoContext {
-    [key: string]: unknown;
-    get: (key: string) => unknown;
-    req: {
-        header: (name: string) => string | undefined;
-        method: string;
-        path: string;
-        raw: {
-            headers: Headers;
-        };
+  [key: string]: unknown;
+  get: (key: string) => unknown;
+  req: {
+    header: (name: string) => string | undefined;
+    method: string;
+    path: string;
+    raw: {
+      headers: Headers;
     };
-    res: {
-        status: number;
-    };
-    set: (key: string, value: unknown) => void;
+  };
+  res: {
+    status: number;
+  };
+  set: (key: string, value: unknown) => void;
 }
 /**
- * Hono-compatible next function.
- */
+* Hono-compatible next function.
+*/
 type PailHonoNext = () => Promise<void>;
 /**
- * The Hono middleware function signature returned by `pailMiddleware()`.
- */
+* The Hono middleware function signature returned by `pailMiddleware()`.
+*/
 type PailHonoMiddleware = (c: PailHonoContext, next: PailHonoNext) => Promise<void>;
 /**
- * Configuration options for the Hono pail middleware.
- * @template T - Custom logger type names from the pail instance
- */
+* Configuration options for the Hono pail middleware.
+* @template T - Custom logger type names from the pail instance
+*/
 type HonoMiddlewareOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Retrieve the WideEvent logger from Hono context.
- * Must be called within a request handler where pail middleware is active.
- * @param c The Hono context object
- * @returns The request-scoped WideEvent logger
- * @throws Error if the middleware is not registered
- */
+* Retrieve the WideEvent logger from Hono context.
+* Must be called within a request handler where pail middleware is active.
+* @param c The Hono context object
+* @returns The request-scoped WideEvent logger
+* @throws Error if the middleware is not registered
+*/
 declare const useLogger: (c: PailHonoContext) => WideEvent;
 /**
- * Create Hono middleware that attaches a WideEvent logger to each request.
- *
- * The logger is available via:
- * - `c.get("log")` on the Hono context
- * - `useLogger(c)` helper function
- *
- * The wide event is automatically emitted when the handler completes or throws.
- * @param options Middleware configuration
- * @returns Hono middleware function
- * @example
- * ```typescript
- * import { Hono } from "hono";
- * import { createPail } from "@visulima/pail";
- * import { pailMiddleware, useLogger } from "@visulima/pail/middleware/hono";
- *
- * const app = new Hono();
- * const logger = createPail();
- *
- * app.use("*", pailMiddleware({ pail: logger }));
- *
- * app.get("/api/users", (c) => {
- *   const log = useLogger(c);
- *   log.set({ user: { id: 1 } });
- *   return c.json({ ok: true });
- * });
- * ```
- */
-export declare const pailMiddleware: <T extends string = string>(options: HonoMiddlewareOptions<T>) => PailHonoMiddleware;
-export { useLogger };
-export type { HonoMiddlewareOptions, PailHonoContext, PailHonoMiddleware, PailHonoNext };
-export type { WideEvent } from "../wide-event.d.ts";
+* Create Hono middleware that attaches a WideEvent logger to each request.
+*
+* The logger is available via:
+* - `c.get("log")` on the Hono context
+* - `useLogger(c)` helper function
+*
+* The wide event is automatically emitted when the handler completes or throws.
+* @param options Middleware configuration
+* @returns Hono middleware function
+* @example
+* ```typescript
+* import { Hono } from "hono";
+* import { createPail } from "@visulima/pail";
+* import { pailMiddleware, useLogger } from "@visulima/pail/middleware/hono";
+*
+* const app = new Hono();
+* const logger = createPail();
+*
+* app.use("*", pailMiddleware({ pail: logger }));
+*
+* app.get("/api/users", (c) => {
+*   const log = useLogger(c);
+*   log.set({ user: { id: 1 } });
+*   return c.json({ ok: true });
+* });
+* ```
+*/
+declare const pailMiddleware: <T extends string = string>(options: HonoMiddlewareOptions<T>) => PailHonoMiddleware;
+export { type HonoMiddlewareOptions, type PailHonoContext, type PailHonoMiddleware, type PailHonoNext, type WideEvent, pailMiddleware, useLogger };

package/dist/middleware/next/handler.d.ts

@@ -1,36 +1,103 @@
-import type { PailMiddlewareOptions } from "../shared/create-middleware-logger.d.ts";
+import { P as PailMiddlewareOptions } from "../../packem_shared/create-middleware-logger.d-DheMh8q4.js";
+import { W as WideEvent } from "../../packem_shared/wide-event.d-B-t8ZnhI.js";
+import 'node:async_hooks';
+import "../../packem_shared/types.d-BeLumqgD.js";
+import '@visulima/colorize';
+import '@visulima/interactive-manager';
+import 'safe-stable-stringify';
+/**
+* Minimal type definitions to avoid requiring next as a dependency.
+*/
+interface NextRequest {
+  headers: Headers;
+  nextUrl: {
+    pathname: string;
+  };
+}
+interface NextResponse {
+  headers: Headers;
+}
+interface NextResponseConstructor {
+  next: (options?: {
+    request?: {
+      headers?: Headers;
+    };
+  }) => NextResponse;
+}
+/**
+* Options for the Next.js pail middleware.
+*/
+interface PailNextMiddlewareOptions {
+  /**
+  * Glob patterns for paths to exclude from logging.
+  * Excluded paths won't get request IDs or timing headers.
+  * @example ["/_next/**", "/favicon.ico"]
+  */
+  exclude?: string[];
+  /**
+  * Glob patterns for paths to include in logging.
+  * If not set, all non-excluded paths are included.
+  */
+  include?: string[];
+}
+/**
+* Create a Next.js edge middleware that sets `x-request-id` and `x-pail-start`
+* headers on the request for downstream use by `withPail()`.
+*
+* This middleware runs at the edge and prepares request metadata.
+* The actual wide event logging happens in `withPail()`.
+* @param NextResponseClass The NextResponse class from "next/server.js"
+* @param options Middleware configuration
+* @returns A middleware function
+* @example
+* ```typescript
+* // middleware.ts
+* import { NextResponse } from "next/server.js";
+* import { pailMiddleware } from "@visulima/pail/middleware/next";
+*
+* const middleware = pailMiddleware(NextResponse, {
+*   exclude: ["/_next/**", "/favicon.ico"],
+* });
+*
+* export default middleware;
+* ```
+*/
+declare const pailMiddleware: (NextResponseClass: NextResponseConstructor, options?: PailNextMiddlewareOptions) => (request: NextRequest) => NextResponse;
+/**
+* Retrieve the request-scoped WideEvent logger from AsyncLocalStorage.
+* Must be called within a `withPail()` wrapped handler or server action.
+* @returns The request-scoped WideEvent logger
+* @throws Error if called outside of a withPail context
+*/
+declare const useLogger: () => WideEvent;
 type NextPailOptions<T extends string = string> = PailMiddlewareOptions<T>;
 /**
- * Create a `withPail` wrapper function for Next.js route handlers and server actions.
- *
- * Wraps handler execution in AsyncLocalStorage so that `useLogger()` works
- * anywhere in the async call stack. The wide event is automatically emitted
- * when the handler completes or throws.
- * @param options Configuration options
- * @returns A `withPail` wrapper function
- * @example
- * ```typescript
- * // lib/pail.ts
- * import { createPail } from "@visulima/pail";
- * import { createWithPail } from "@visulima/pail/middleware/next";
- *
- * const logger = createPail();
- * export const withPail = createWithPail({ pail: logger });
- *
- * // app/api/users/route.ts
- * import { withPail } from "@/lib/pail";
- * import { useLogger } from "@visulima/pail/middleware/next";
- *
- * export const GET = withPail(async (request: Request) => {
- *   const log = useLogger();
- *   log.set({ user: { id: 1 } });
- *   return Response.json({ ok: true });
- * });
- * ```
- */
-export declare const createWithPail: <T extends string = string>(options: NextPailOptions<T>) => <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn> | TReturn) => (...args: TArgs) => Promise<TReturn>;
-export type { NextPailOptions };
-export type { WideEvent } from "../../wide-event.d.ts";
-export type { PailNextMiddlewareOptions } from "./middleware/next/middleware.d.ts";
-export { pailMiddleware } from "./middleware/next/middleware.d.ts";
-export { useLogger } from "./storage.d.ts";
+* Create a `withPail` wrapper function for Next.js route handlers and server actions.
+*
+* Wraps handler execution in AsyncLocalStorage so that `useLogger()` works
+* anywhere in the async call stack. The wide event is automatically emitted
+* when the handler completes or throws.
+* @param options Configuration options
+* @returns A `withPail` wrapper function
+* @example
+* ```typescript
+* // lib/pail.ts
+* import { createPail } from "@visulima/pail";
+* import { createWithPail } from "@visulima/pail/middleware/next";
+*
+* const logger = createPail();
+* export const withPail = createWithPail({ pail: logger });
+*
+* // app/api/users/route.ts
+* import { withPail } from "@/lib/pail";
+* import { useLogger } from "@visulima/pail/middleware/next";
+*
+* export const GET = withPail(async (request: Request) => {
+*   const log = useLogger();
+*   log.set({ user: { id: 1 } });
+*   return Response.json({ ok: true });
+* });
+* ```
+*/
+declare const createWithPail: <T extends string = string>(options: NextPailOptions<T>) => <TArgs extends unknown[], TReturn>(handler: (...args: TArgs) => Promise<TReturn> | TReturn) => (...args: TArgs) => Promise<TReturn>;
+export { type NextPailOptions, type PailNextMiddlewareOptions, type WideEvent, createWithPail, pailMiddleware, useLogger };