@amkisko/json-logging 0.0.0-stage → 0.1.1

package/dist/http-context.js

@@ -0,0 +1,156 @@
+import { withContext } from "./context.js";
+import { sanitizeError, sanitizeString } from "./sanitize.js";
+/** Accept inbound request ids that are short and correlation-safe. */
+export const REQUEST_ID_PATTERN = /^[\w.\-:]{1,128}$/;
+let fallbackCounter = 0;
+/** Monotonic fallback request id when crypto UUID is unavailable. */
+export function fallbackRequestId(now = Date.now) {
+    fallbackCounter += 1;
+    return `req_${now().toString(36)}_${fallbackCounter.toString(36)}`;
+}
+/** Prefer `crypto.randomUUID`, else {@link fallbackRequestId}. */
+export function defaultRandomId(randomUUID) {
+    const resolved = randomUUID === undefined ? globalThis.crypto?.randomUUID?.bind(globalThis.crypto) : randomUUID;
+    if (typeof resolved === "function") {
+        return resolved();
+    }
+    return fallbackRequestId();
+}
+/** True when `value` matches {@link REQUEST_ID_PATTERN}. */
+export function isValidRequestId(value) {
+    return REQUEST_ID_PATTERN.test(value);
+}
+/** Keep a valid inbound id, otherwise allocate a new one. */
+export function allocateRequestId(existing, randomId = defaultRandomId) {
+    if (existing && isValidRequestId(existing)) {
+        return existing;
+    }
+    try {
+        return randomId();
+    }
+    catch {
+        return fallbackRequestId();
+    }
+}
+/** Pathname from an absolute or relative URL string. */
+export function requestPathFromUrl(url) {
+    if (url.length === 0) {
+        return undefined;
+    }
+    try {
+        return new URL(url, "http://localhost").pathname;
+    }
+    catch {
+        const query = url.indexOf("?");
+        const hash = url.indexOf("#");
+        let end = url.length;
+        if (query >= 0) {
+            end = query;
+        }
+        if (hash >= 0 && hash < end) {
+            end = hash;
+        }
+        const path = url.slice(0, end);
+        return path.length > 0 ? path : undefined;
+    }
+}
+function isHeaderBag(value) {
+    return typeof Reflect.get(value, "get") === "function";
+}
+function headerGet(headers, name) {
+    if (!headers) {
+        return null;
+    }
+    if (isHeaderBag(headers)) {
+        return headers.get(name);
+    }
+    const direct = Reflect.get(headers, name) ?? Reflect.get(headers, name.toLowerCase());
+    if (Array.isArray(direct)) {
+        const first = direct[0];
+        return typeof first === "string" ? first : null;
+    }
+    return typeof direct === "string" ? direct : null;
+}
+/** Pick named keys from a bag; missing keys are omitted. */
+export function pickContextKeys(bag, keys) {
+    if (!bag || !keys || keys.length === 0) {
+        return {};
+    }
+    const out = {};
+    for (const key of keys) {
+        if (Object.hasOwn(bag, key)) {
+            out[key] = bag[key];
+        }
+    }
+    return out;
+}
+/** Build requestId / method / path fields from {@link HttpRequestInput}. */
+export function httpFieldsFrom(input, headerName = "x-request-id") {
+    const fromHeader = headerGet(input.headers, headerName);
+    const requestId = allocateRequestId(input.requestId ?? fromHeader);
+    const fields = { requestId };
+    if (input.method) {
+        fields.method = input.method;
+    }
+    const path = input.path ?? (input.url ? requestPathFromUrl(input.url) : undefined);
+    if (path) {
+        fields.path = path;
+    }
+    return fields;
+}
+/** Copy allowlisted header names into a sanitized string map. */
+export function pickAllowlistedHeaders(headers, names) {
+    if (!headers || !names || names.length === 0) {
+        return {};
+    }
+    const out = {};
+    for (const name of names) {
+        const value = headerGet(headers, name);
+        if (value !== null && value.length > 0) {
+            out[name] = sanitizeString(value);
+        }
+    }
+    return out;
+}
+/**
+ * One structured access line. Level is error when status >= 500 or error is set.
+ */
+export function logRequestCompletion(logger, fields) {
+    const payload = {
+        event: "http_request",
+        status: fields.status,
+        elapsedMs: fields.elapsedMs,
+    };
+    if (fields.method) {
+        payload.method = fields.method;
+    }
+    if (fields.path) {
+        payload.path = fields.path;
+    }
+    if (fields.error instanceof Error) {
+        Object.assign(payload, sanitizeError(fields.error));
+    }
+    else if (fields.error !== undefined) {
+        payload.error = {
+            message: sanitizeString(String(fields.error)),
+        };
+    }
+    const level = fields.status >= 500 || fields.error !== undefined ? "error" : "info";
+    if (level === "error") {
+        logger.error(payload);
+    }
+    else {
+        logger.info(payload);
+    }
+}
+/** Run `fn` under ALS context built from the HTTP request input. */
+export function withHttpContext(input, fn, options = {}) {
+    const headerName = options.headerName ?? "x-request-id";
+    const fields = {
+        ...pickAllowlistedHeaders(input.headers, options.headersAllowlist),
+        ...(options.extra ?? {}),
+        ...httpFieldsFrom(input, headerName),
+    };
+    return withContext(fields, fn);
+}
+//# sourceMappingURL=http-context.js.map

package/dist/http.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared HTTP helpers: ambient logger binding, request context, and completion lines.
+ * Framework adapters live on separate entrypoints (`./hono`, `./express`, ...).
+ *
+ * @example
+ * ```ts
+ * import { bindHttpLogger, httpLogger, withHttpContext } from "@amkisko/json-logging/http";
+ *
+ * bindHttpLogger(httpLogger({ loggerOptions: { base: { service: "api" } } }));
+ * await withHttpContext({ method: "GET", path: "/" }, () => {
+ *   httpLogger().info("inside request");
+ * });
+ * ```
+ *
+ * @module
+ */
+import type { WithHttpContextOptions } from "./http-context.js";
+import type { Logger } from "./logger.js";
+export { bindHttpLogger, bindLoggerFromOptions, resetHttpLoggerForTests, } from "./http-ambient.js";
+export type { HeaderBag, HttpRequestInput, RequestCompletionFields, WithHttpContextOptions, } from "./http-context.js";
+export { allocateRequestId, defaultRandomId, fallbackRequestId, httpFieldsFrom, isValidRequestId, logRequestCompletion, pickAllowlistedHeaders, pickContextKeys, REQUEST_ID_PATTERN, requestPathFromUrl, withHttpContext, } from "./http-context.js";
+/** Resolve the ambient HTTP logger, or create and bind one from options. */
+export declare function httpLogger(options?: WithHttpContextOptions): Logger;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.js

@@ -0,0 +1,34 @@
+/**
+ * Shared HTTP helpers: ambient logger binding, request context, and completion lines.
+ * Framework adapters live on separate entrypoints (`./hono`, `./express`, ...).
+ *
+ * @example
+ * ```ts
+ * import { bindHttpLogger, httpLogger, withHttpContext } from "@amkisko/json-logging/http";
+ *
+ * bindHttpLogger(httpLogger({ loggerOptions: { base: { service: "api" } } }));
+ * await withHttpContext({ method: "GET", path: "/" }, () => {
+ *   httpLogger().info("inside request");
+ * });
+ * ```
+ *
+ * @module
+ */
+import { bindHttpLogger, getAmbientHttpLogger } from "./http-ambient.js";
+import { createLogger } from "./json-logging.js";
+export { bindHttpLogger, bindLoggerFromOptions, resetHttpLoggerForTests, } from "./http-ambient.js";
+export { allocateRequestId, defaultRandomId, fallbackRequestId, httpFieldsFrom, isValidRequestId, logRequestCompletion, pickAllowlistedHeaders, pickContextKeys, REQUEST_ID_PATTERN, requestPathFromUrl, withHttpContext, } from "./http-context.js";
+/** Resolve the ambient HTTP logger, or create and bind one from options. */
+export function httpLogger(options) {
+    if (options?.logger) {
+        return options.logger;
+    }
+    const ambient = getAmbientHttpLogger();
+    if (ambient) {
+        return ambient;
+    }
+    const created = createLogger(options?.loggerOptions);
+    bindHttpLogger(created);
+    return created;
+}
+//# sourceMappingURL=http.js.map

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structured JSON logging with ActiveSupport-style `tagged` and `withContext`.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, withContext } from "@amkisko/json-logging";
+ *
+ * const logger = createLogger({ base: { service: "api" } });
+ * await withContext({ requestId: "abc" }, async () => {
+ *   logger.info("handled request");
+ * });
+ * ```
+ *
+ * @module
+ */
+export type { ConsoleMethodName, ConsoleMethods } from "./console-state.js";
+export { captureConsoleMethods, getBridgeOriginals, isInBridge, } from "./console-state.js";
+export type { AlsConstructor, AlsInstance, ContextFields } from "./context.js";
+export { getBlockTags, getContext, isAsyncLocalStorageAvailable, peekLogStore, withContext, } from "./context.js";
+export { createLogger, JsonLogging } from "./json-logging.js";
+export { Logger } from "./logger.js";
+export type { CompiledRedactPath } from "./redact.js";
+export { applyCompiledRedactPaths, applyRedactPaths, compileRedactPaths, } from "./redact.js";
+export { isSensitiveKey, MAX_CONTEXT_SIZE, MAX_DEPTH, MAX_STRING_LENGTH, prepareTags, sanitizeError, sanitizeHash, sanitizeString, } from "./sanitize.js";
+export { buildFallbackRecord, buildRecord, currentTimestamp, formatTimestamp, parseMessage, SYSTEM_KEYS, toJsonLine, } from "./serialize.js";
+export { isEnabled, LEVEL_ORDER, SEVERITY_NAMES, severityName } from "./severity.js";
+export { consoleSink, consoleSinkFrom, streamSink } from "./sinks.js";
+export type { PerformanceLike } from "./timestamp.js";
+export { defaultPerformance } from "./timestamp.js";
+export type { ContextProvider, FieldSerializer, JsonPrimitive, JsonValue, Level, LoggerOptions, LogMessage, LogRecord, SeverityName, Sink, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * Structured JSON logging with ActiveSupport-style `tagged` and `withContext`.
+ *
+ * @example
+ * ```ts
+ * import { createLogger, withContext } from "@amkisko/json-logging";
+ *
+ * const logger = createLogger({ base: { service: "api" } });
+ * await withContext({ requestId: "abc" }, async () => {
+ *   logger.info("handled request");
+ * });
+ * ```
+ *
+ * @module
+ */
+export { captureConsoleMethods, getBridgeOriginals, isInBridge, } from "./console-state.js";
+export { getBlockTags, getContext, isAsyncLocalStorageAvailable, peekLogStore, withContext, } from "./context.js";
+export { createLogger, JsonLogging } from "./json-logging.js";
+export { Logger } from "./logger.js";
+export { applyCompiledRedactPaths, applyRedactPaths, compileRedactPaths, } from "./redact.js";
+export { isSensitiveKey, MAX_CONTEXT_SIZE, MAX_DEPTH, MAX_STRING_LENGTH, prepareTags, sanitizeError, sanitizeHash, sanitizeString, } from "./sanitize.js";
+export { buildFallbackRecord, buildRecord, currentTimestamp, formatTimestamp, parseMessage, SYSTEM_KEYS, toJsonLine, } from "./serialize.js";
+export { isEnabled, LEVEL_ORDER, SEVERITY_NAMES, severityName } from "./severity.js";
+export { consoleSink, consoleSinkFrom, streamSink } from "./sinks.js";
+export { defaultPerformance } from "./timestamp.js";
+//# sourceMappingURL=index.js.map

package/dist/json-logging.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Create a {@link Logger} with optional level, sink, base fields, redact, and serializers. */
+export declare function createLogger(options?: LoggerOptions): Logger;
+/** ActiveSupport-style factory: `JsonLogging.new(options)` mirrors {@link createLogger}. */
+export declare const JsonLogging: {
+    new: (options?: LoggerOptions) => Logger;
+};
+//# sourceMappingURL=json-logging.d.ts.map

package/dist/json-logging.js

@@ -0,0 +1,12 @@
+import { Logger } from "./logger.js";
+/** Create a {@link Logger} with optional level, sink, base fields, redact, and serializers. */
+export function createLogger(options = {}) {
+    return new Logger(options);
+}
+/** ActiveSupport-style factory: `JsonLogging.new(options)` mirrors {@link createLogger}. */
+export const JsonLogging = {
+    new(options = {}) {
+        return createLogger(options);
+    },
+};
+//# sourceMappingURL=json-logging.js.map

package/dist/koa.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Koa middleware that attaches request context (and optional completion lines).
+ *
+ * @example
+ * ```ts
+ * import { withKoaLogging } from "@amkisko/json-logging/koa";
+ * app.use(withKoaLogging({ logCompletion: true }));
+ * ```
+ *
+ * @module
+ */
+import type { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Minimal Koa context shape (no Koa runtime dependency). */
+export type KoaContextLike = {
+    method: string;
+    path?: string;
+    url?: string;
+    status?: number;
+    get: (name: string) => string;
+};
+/** Options for {@link withKoaLogging}. */
+export type WithKoaLoggingOptions = {
+    headerName?: string;
+    logger?: Logger;
+    loggerOptions?: LoggerOptions;
+    headersAllowlist?: readonly string[];
+    logCompletion?: boolean;
+};
+/** Koa-style middleware function. */
+export type KoaMiddleware = (ctx: KoaContextLike, next: () => Promise<void>) => Promise<void>;
+/** Build Koa middleware: `(ctx, next) => ...`. Bind loggers via `./http`. */
+export declare function withKoaLogging(options?: WithKoaLoggingOptions): KoaMiddleware;
+//# sourceMappingURL=koa.d.ts.map

package/dist/koa.js

@@ -0,0 +1,54 @@
+/**
+ * Koa middleware that attaches request context (and optional completion lines).
+ *
+ * @example
+ * ```ts
+ * import { withKoaLogging } from "@amkisko/json-logging/koa";
+ * app.use(withKoaLogging({ logCompletion: true }));
+ * ```
+ *
+ * @module
+ */
+import { bindLoggerFromOptions, getAmbientHttpLogger } from "./http-ambient.js";
+import { httpFieldsFrom, logRequestCompletion, withHttpContext, } from "./http-context.js";
+/** Build Koa middleware: `(ctx, next) => ...`. Bind loggers via `./http`. */
+export function withKoaLogging(options = {}) {
+    bindLoggerFromOptions(options);
+    const headerName = options.headerName ?? "x-request-id";
+    return async (ctx, next) => {
+        const existing = ctx.get(headerName);
+        const input = {
+            method: ctx.method,
+            path: ctx.path,
+            url: ctx.url,
+            requestId: existing.length > 0 ? existing : undefined,
+            headers: {
+                get: (name) => {
+                    const value = ctx.get(name);
+                    return value.length > 0 ? value : null;
+                },
+            },
+        };
+        const started = Date.now();
+        const fields = httpFieldsFrom(input, headerName);
+        await withHttpContext(input, async () => {
+            try {
+                await next();
+            }
+            finally {
+                if (options.logCompletion) {
+                    const logger = options.logger ?? getAmbientHttpLogger();
+                    if (logger) {
+                        logRequestCompletion(logger, {
+                            method: typeof fields.method === "string" ? fields.method : undefined,
+                            path: typeof fields.path === "string" ? fields.path : undefined,
+                            status: typeof ctx.status === "number" ? ctx.status : 0,
+                            elapsedMs: Date.now() - started,
+                        });
+                    }
+                }
+            }
+        }, options);
+    };
+}
+//# sourceMappingURL=koa.js.map

package/dist/logger.d.ts

@@ -0,0 +1,46 @@
+import type { ContextProvider, FieldSerializer, Level, LoggerOptions, LogMessage, Sink } from "./types.js";
+/** Structured logger: severity methods, sticky tags, child loggers, never-raise emit path. */
+export declare class Logger {
+    /** Minimum level that will be written. */
+    readonly level: Level;
+    /** Destination for JSON lines. */
+    readonly sink: Sink;
+    /** Sanitized root fields merged into every line. */
+    readonly base: Record<string, unknown>;
+    /** Optional clock override (tests). */
+    readonly clock?: () => Date;
+    /** Sticky tags from construction or {@link Logger.tagged}. */
+    readonly tags: readonly string[];
+    /** Configured redact paths (dot notation). */
+    readonly redact: readonly string[];
+    /** Root-field serializers. */
+    readonly serializers: Readonly<Record<string, FieldSerializer>>;
+    /** Optional ambient context provider. */
+    readonly contextProvider?: ContextProvider;
+    private readonly compiledRedact;
+    constructor(options?: LoggerOptions);
+    /** True when a message at `level` would be emitted. */
+    isLevelEnabled(level: Level): boolean;
+    /** Emit a debug line when enabled. */
+    debug(message: LogMessage): void;
+    /** Emit an info line when enabled. */
+    info(message: LogMessage): void;
+    /** Emit a warn line when enabled. */
+    warn(message: LogMessage): void;
+    /** Emit an error line when enabled. */
+    error(message: LogMessage): void;
+    /** Emit a fatal line when enabled. */
+    fatal(message: LogMessage): void;
+    /** Child logger with extra root bindings merged into `base`. */
+    child(bindings: Record<string, unknown>): Logger;
+    /**
+     * Block form runs `fn` with nested tags; sticky form returns a child logger.
+     * Pass tags then a callback, or only tags for a sticky child.
+     */
+    tagged(callback: () => unknown): unknown;
+    tagged(tag: string | number | boolean, callback: () => unknown): unknown;
+    tagged(tag: string | number | boolean, tag2: string | number | boolean, callback: () => unknown): unknown;
+    tagged(...tags: (string | number | boolean | null | undefined)[]): Logger;
+    private log;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,130 @@
+import { withBlockTags } from "./context.js";
+import { compileRedactPaths } from "./redact.js";
+import { prepareTags, sanitizeHash } from "./sanitize.js";
+import { buildFallbackRecord, buildRecord, toJsonLine } from "./serialize.js";
+import { isEnabled } from "./severity.js";
+import { consoleSink } from "./sinks.js";
+function isCallback(value) {
+    return typeof value === "function";
+}
+/** Structured logger: severity methods, sticky tags, child loggers, never-raise emit path. */
+export class Logger {
+    /** Minimum level that will be written. */
+    level;
+    /** Destination for JSON lines. */
+    sink;
+    /** Sanitized root fields merged into every line. */
+    base;
+    /** Optional clock override (tests). */
+    clock;
+    /** Sticky tags from construction or {@link Logger.tagged}. */
+    tags;
+    /** Configured redact paths (dot notation). */
+    redact;
+    /** Root-field serializers. */
+    serializers;
+    /** Optional ambient context provider. */
+    contextProvider;
+    compiledRedact;
+    constructor(options = {}) {
+        this.level = options.level ?? "info";
+        this.sink = options.sink ?? consoleSink();
+        this.base = options.base ? sanitizeHash(options.base) : {};
+        this.clock = options.clock;
+        this.tags = options.tags ? prepareTags(options.tags) : [];
+        this.redact = options.redact ? [...options.redact] : [];
+        this.serializers = options.serializers ? { ...options.serializers } : {};
+        this.contextProvider = options.contextProvider;
+        this.compiledRedact = compileRedactPaths(this.redact);
+    }
+    /** True when a message at `level` would be emitted. */
+    isLevelEnabled(level) {
+        return isEnabled(this.level, level);
+    }
+    /** Emit a debug line when enabled. */
+    debug(message) {
+        this.log("debug", message);
+    }
+    /** Emit an info line when enabled. */
+    info(message) {
+        this.log("info", message);
+    }
+    /** Emit a warn line when enabled. */
+    warn(message) {
+        this.log("warn", message);
+    }
+    /** Emit an error line when enabled. */
+    error(message) {
+        this.log("error", message);
+    }
+    /** Emit a fatal line when enabled. */
+    fatal(message) {
+        this.log("fatal", message);
+    }
+    /** Child logger with extra root bindings merged into `base`. */
+    child(bindings) {
+        return new Logger({
+            level: this.level,
+            sink: this.sink,
+            clock: this.clock,
+            tags: this.tags,
+            redact: this.redact,
+            serializers: this.serializers,
+            contextProvider: this.contextProvider,
+            base: { ...this.base, ...sanitizeHash(bindings) },
+        });
+    }
+    tagged(...args) {
+        if (args.length === 0) {
+            return this;
+        }
+        const last = args[args.length - 1];
+        if (isCallback(last)) {
+            const tags = prepareTags(args.slice(0, -1));
+            return withBlockTags(tags, last);
+        }
+        const tags = prepareTags(args);
+        return new Logger({
+            level: this.level,
+            sink: this.sink,
+            clock: this.clock,
+            base: this.base,
+            redact: this.redact,
+            serializers: this.serializers,
+            contextProvider: this.contextProvider,
+            tags: [...this.tags, ...tags],
+        });
+    }
+    log(level, message) {
+        if (!this.isLevelEnabled(level)) {
+            return;
+        }
+        try {
+            const record = buildRecord({
+                message,
+                level,
+                stickyTags: this.tags,
+                base: this.base,
+                preparedBase: true,
+                preparedTags: true,
+                clock: this.clock,
+                compiledRedact: this.compiledRedact,
+                serializers: this.serializers,
+                contextProvider: this.contextProvider,
+            });
+            const line = toJsonLine(record);
+            void this.sink.write(line, record);
+        }
+        catch (error) {
+            try {
+                const fallback = buildFallbackRecord(level, message, error, this.clock);
+                const line = toJsonLine(fallback);
+                void this.sink.write(line, fallback);
+            }
+            catch {
+                // Last resort: never throw from the log path.
+            }
+        }
+    }
+}
+//# sourceMappingURL=logger.js.map

package/dist/next.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Next.js helpers: wrap middleware or route handlers with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRequestLogging } from "@amkisko/json-logging/next";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * export default withRequestLogging(async (req) => {
+ *   httpLogger().info({ path: req.nextUrl?.pathname });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { allocateRequestId, defaultRandomId, fallbackRequestId } from "./http-context.js";
+import type { Logger } from "./logger.js";
+import type { LoggerOptions } from "./types.js";
+/** Minimal Next request shape used by the wrapper (no Next runtime dependency). */
+export type RequestLike = {
+    headers: Headers;
+    method?: string;
+    url?: string;
+    nextUrl?: {
+        pathname?: string;
+    };
+};
+/** Options for {@link withRequestLogging}. */
+export type WithRequestLoggingOptions = {
+    headerName?: string;
+    logger?: Logger;
+    loggerOptions?: LoggerOptions;
+};
+/** Re-export request-id helpers for Next entrypoint consumers. */
+export { allocateRequestId, defaultRandomId, fallbackRequestId };
+/**
+ * Wrap a Next.js middleware or route handler with request-scoped context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export declare function withRequestLogging<TArgs extends unknown[], TResult>(handler: (request: RequestLike, ...rest: TArgs) => TResult | Promise<TResult>, options?: WithRequestLoggingOptions): (request: RequestLike, ...rest: TArgs) => Promise<TResult>;
+//# sourceMappingURL=next.d.ts.map

package/dist/next.js

@@ -0,0 +1,35 @@
+/**
+ * Next.js helpers: wrap middleware or route handlers with request-scoped log context.
+ *
+ * @example
+ * ```ts
+ * import { withRequestLogging } from "@amkisko/json-logging/next";
+ * import { httpLogger } from "@amkisko/json-logging/http";
+ *
+ * export default withRequestLogging(async (req) => {
+ *   httpLogger().info({ path: req.nextUrl?.pathname });
+ * });
+ * ```
+ *
+ * @module
+ */
+import { bindLoggerFromOptions } from "./http-ambient.js";
+import { allocateRequestId, defaultRandomId, fallbackRequestId, withHttpContext, } from "./http-context.js";
+/** Re-export request-id helpers for Next entrypoint consumers. */
+export { allocateRequestId, defaultRandomId, fallbackRequestId };
+/**
+ * Wrap a Next.js middleware or route handler with request-scoped context.
+ * Bind loggers via `@amkisko/json-logging/http` (`bindHttpLogger` / `httpLogger`).
+ */
+export function withRequestLogging(handler, options = {}) {
+    bindLoggerFromOptions(options);
+    return async (request, ...rest) => {
+        return (await withHttpContext({
+            headers: request.headers,
+            method: request.method,
+            url: request.url,
+            path: request.nextUrl?.pathname,
+        }, () => handler(request, ...rest), options));
+    };
+}
+//# sourceMappingURL=next.js.map

package/dist/objects.d.ts

@@ -0,0 +1,12 @@
+export declare function isPlainObject(value: unknown): value is {
+    [key: string]: unknown;
+};
+export declare function plainObjectFrom(value: object): {
+    [key: string]: unknown;
+};
+export declare function readObjectField(record: {
+    [key: string]: unknown;
+}, key: string): {
+    [key: string]: unknown;
+};
+//# sourceMappingURL=objects.d.ts.map

package/dist/objects.js

@@ -0,0 +1,18 @@
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function plainObjectFrom(value) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+        result[key] = Reflect.get(value, key);
+    }
+    return result;
+}
+export function readObjectField(record, key) {
+    const value = record[key];
+    if (isPlainObject(value)) {
+        return value;
+    }
+    return {};
+}
+//# sourceMappingURL=objects.js.map