@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/stdlib/sloppy/request-id.js

@@ -0,0 +1,184 @@
+import { isPlainObject } from "./internal/shared.js";
+
+const DEFAULT_HEADER = "x-request-id";
+const MANAGED_RESPONSE_HEADERS = new Set([
+    "connection",
+    "content-type",
+    "content-length",
+    "transfer-encoding",
+    "keep-alive",
+]);
+
+function isHeaderNameChar(value) {
+    return (value >= "A" && value <= "Z") ||
+        (value >= "a" && value <= "z") ||
+        (value >= "0" && value <= "9") ||
+        value === "!" ||
+        value === "#" ||
+        value === "$" ||
+        value === "%" ||
+        value === "&" ||
+        value === "'" ||
+        value === "*" ||
+        value === "+" ||
+        value === "-" ||
+        value === "." ||
+        value === "^" ||
+        value === "_" ||
+        value === "`" ||
+        value === "|" ||
+        value === "~";
+}
+
+function headerNameSafe(name) {
+    if (typeof name !== "string" || name.length === 0) {
+        return false;
+    }
+    for (const ch of name) {
+        if (!isHeaderNameChar(ch)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function responseHeaderAllowed(name) {
+    return !MANAGED_RESPONSE_HEADERS.has(name.toLowerCase());
+}
+
+function headerValueSafe(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x09) || code === 0x7F) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function requestHeader(context, name) {
+    const headers = context?.request?.headers;
+    if (headers === undefined || headers === null) {
+        return undefined;
+    }
+    if (typeof headers.get === "function") {
+        return headers.get(name) ?? headers.get(name.toLowerCase()) ?? undefined;
+    }
+    if (isPlainObject(headers)) {
+        const lowered = name.toLowerCase();
+        for (const [key, value] of Object.entries(headers)) {
+            if (key.toLowerCase() === lowered) {
+                return value;
+            }
+        }
+    }
+    return undefined;
+}
+
+function appendResponseHeader(result, header, requestId) {
+    if (result === null || typeof result !== "object") {
+        return result;
+    }
+
+    const headers = {
+        ...(isPlainObject(result.headers) ? result.headers : {}),
+        [header]: requestId,
+    };
+
+    return Object.freeze({
+        ...result,
+        headers: Object.freeze(headers),
+    });
+}
+
+function recordResponseHeader(context, header, requestId) {
+    const current = isPlainObject(context.__sloppyResponseHeaders)
+        ? context.__sloppyResponseHeaders
+        : {};
+    Object.defineProperty(context, "__sloppyResponseHeaders", {
+        value: Object.freeze({
+            ...current,
+            [header]: requestId,
+        }),
+        enumerable: false,
+        writable: true,
+        configurable: true,
+    });
+}
+
+function normalizeOptions(options) {
+    if (options !== undefined && !isPlainObject(options)) {
+        throw new TypeError("Sloppy RequestId.defaults options must be a plain object.");
+    }
+
+    const header = options?.header ?? DEFAULT_HEADER;
+    if (!headerNameSafe(header) || !responseHeaderAllowed(header)) {
+        throw new TypeError("Sloppy RequestId header must be a safe unmanaged HTTP header name.");
+    }
+
+    const responseHeader = options?.responseHeader ?? true;
+    if (typeof responseHeader !== "boolean") {
+        throw new TypeError("Sloppy RequestId responseHeader option must be a boolean.");
+    }
+
+    const trustIncoming = options?.trustIncoming ?? false;
+    if (typeof trustIncoming !== "boolean") {
+        throw new TypeError("Sloppy RequestId trustIncoming option must be a boolean.");
+    }
+
+    const generator = options?.generator;
+    if (generator !== undefined && typeof generator !== "function") {
+        throw new TypeError("Sloppy RequestId generator option must be a function.");
+    }
+
+    return Object.freeze({
+        header,
+        responseHeader,
+        trustIncoming,
+        generator,
+    });
+}
+
+function defaults(options) {
+    const normalized = normalizeOptions(options);
+    let counter = 0;
+    const generate = normalized.generator ?? (() => {
+        counter += 1;
+        return `req-${counter}`;
+    });
+
+    async function requestIdMiddleware(context, next) {
+        const incoming = normalized.trustIncoming
+            ? requestHeader(context, normalized.header)
+            : undefined;
+        const requestId = headerValueSafe(incoming) ? incoming : generate();
+
+        if (!headerValueSafe(requestId)) {
+            throw new TypeError("Sloppy RequestId generator must return a safe non-empty value.");
+        }
+
+        Object.defineProperty(context, "requestId", {
+            value: requestId,
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+        if (normalized.responseHeader) {
+            recordResponseHeader(context, normalized.header, requestId);
+        }
+
+        const result = await next();
+        return normalized.responseHeader
+            ? appendResponseHeader(result, normalized.header, requestId)
+            : result;
+    }
+
+    return Object.freeze(requestIdMiddleware);
+}
+
+export const RequestId = Object.freeze({
+    defaults,
+});

package/stdlib/sloppy/request-logging.js

@@ -0,0 +1,101 @@
+import { isPlainObject } from "./internal/shared.js";
+
+function normalizeOptions(options) {
+    if (options !== undefined && !isPlainObject(options)) {
+        throw new TypeError("Sloppy RequestLogging.defaults options must be a plain object.");
+    }
+
+    const includeRoute = options?.includeRoute ?? true;
+    const includeDuration = options?.includeDuration ?? true;
+    const includeRequestId = options?.includeRequestId ?? true;
+
+    if (typeof includeRoute !== "boolean") {
+        throw new TypeError("Sloppy RequestLogging includeRoute option must be a boolean.");
+    }
+    if (typeof includeDuration !== "boolean") {
+        throw new TypeError("Sloppy RequestLogging includeDuration option must be a boolean.");
+    }
+    if (typeof includeRequestId !== "boolean") {
+        throw new TypeError("Sloppy RequestLogging includeRequestId option must be a boolean.");
+    }
+
+    return Object.freeze({
+        includeRoute,
+        includeDuration,
+        includeRequestId,
+    });
+}
+
+function requestMethod(context) {
+    return String(context?.request?.method ?? context?.method ?? "GET").toUpperCase();
+}
+
+function requestPath(context) {
+    const request = context?.request;
+    const value = request?.rawTarget ?? request?.target ?? request?.path ?? context?.path ??
+        context?.routePattern ?? "";
+    return String(value);
+}
+
+function requestRoute(context) {
+    const route = context?.routePattern;
+    return typeof route === "string" && route.length !== 0 ? route : undefined;
+}
+
+function responseStatus(result) {
+    return Number.isInteger(result?.status) ? result.status : 200;
+}
+
+function writeRequestLog(context, options, startedAt, status) {
+    if (context?.log === undefined || typeof context.log.info !== "function") {
+        return;
+    }
+
+    const fields = {
+        method: requestMethod(context),
+        path: requestPath(context),
+        status,
+    };
+
+    if (options.includeRoute) {
+        const route = requestRoute(context);
+        if (route !== undefined) {
+            fields.route = route;
+            fields.routePattern = route;
+        }
+        if (typeof context?.routeName === "string" && context.routeName.length !== 0) {
+            fields.routeName = context.routeName;
+        }
+    }
+    if (options.includeRequestId && typeof context.requestId === "string") {
+        fields.requestId = context.requestId;
+    }
+    if (options.includeDuration) {
+        fields.durationMs = Math.max(0, Date.now() - startedAt);
+    }
+
+    context.log.info("request completed", fields);
+}
+
+function defaults(options) {
+    const normalized = normalizeOptions(options);
+
+    async function requestLoggingMiddleware(context, next) {
+        const startedAt = normalized.includeDuration ? Date.now() : 0;
+
+        try {
+            const result = await next();
+            writeRequestLog(context, normalized, startedAt, responseStatus(result));
+            return result;
+        } catch (error) {
+            writeRequestLog(context, normalized, startedAt, 500);
+            throw error;
+        }
+    }
+
+    return Object.freeze(requestLoggingMiddleware);
+}
+
+export const RequestLogging = Object.freeze({
+    defaults,
+});