bazis 0.97.0 → 0.97.1

package/core/http/HttpServer.ts

@@ -150,8 +150,15 @@ export class HttpServer implements HostedService {
     if (this.options.securityHeaders !== false) {
       serverChain.push(securityHeaders(this.options.securityHeaders ?? {}));
     }
+    // Unexpected errors go to the application logger, like the access log.
+    const errorLogger = this.resolver.tryResolve(LOGGER);
     serverChain.push(
-      errorHandler({ exposeDetails, ...this.options.errorHandler, onUnexpectedError: this.collectErrorHook() }),
+      errorHandler({
+        exposeDetails,
+        ...(errorLogger ? { logger: errorLogger } : {}),
+        ...this.options.errorHandler,
+        onUnexpectedError: this.collectErrorHook(),
+      }),
     );
     this.shortCircuitChain = [...serverChain];
     serverChain.push(...this.collectServerMiddleware());

package/core/http/Middleware/errorHandler.ts

@@ -1,4 +1,5 @@
-import { redactSensitive } from "../../../library/redaction";
+import { REQUEST_ID_STATE_KEY, type Logger } from "../../kernel";
+import { redactSensitive, redactSensitiveText } from "../../../library/redaction";
 import type { HttpContext } from "../HttpContext/HttpContext";
 import { HttpError } from "../Errors/HttpError";
 import type { HttpMiddleware } from "./types";
@@ -9,10 +10,20 @@ export interface ErrorHandlerOptions {
    * never enable in production).
    */
   exposeDetails?: boolean;
-  /** Called for non-{@link HttpError} failures (self-wired via `HTTP_ERROR_HOOK`, e.g. the logging module). */
+  /**
+   * Notified of every non-{@link HttpError} failure, for example to send it to
+   * an error tracker; `HTTP_ERROR_HOOK` registrations are merged in. It does not
+   * replace logging: the error is logged as well.
+   */
   onUnexpectedError?: (ctx: HttpContext, error: unknown) => void;
-  /** Fallback when {@link onUnexpectedError} is omitted or does not handle the error. */
+  /** Replaces the built-in logging of unexpected errors. */
   logError?: (error: unknown) => void;
+  /**
+   * Logger for unexpected errors when {@link logError} is absent: one `error`
+   * line with the method, path, request id and the redacted error. The server
+   * passes the application `LOGGER`; without either, `console.error` is used.
+   */
+  logger?: Logger;
 }
 
 function jsonResponse(status: number, body: unknown, extraHeaders?: readonly [string, string][]): Response {
@@ -33,9 +44,30 @@ function safeJsonResponse(status: number, body: unknown, extraHeaders?: readonly
   }
 }
 
+type ErrorLog = (ctx: HttpContext, error: unknown) => void;
+
+function resolveErrorLog(options: ErrorHandlerOptions): ErrorLog {
+  const { logError, logger } = options;
+  if (logError) {
+    return (_ctx, error) => logError(error);
+  }
+  if (logger) {
+    return (ctx, error) => {
+      const requestId = ctx.state.get(REQUEST_ID_STATE_KEY);
+      logger.error(`${ctx.method} ${ctx.path} failed`, {
+        method: ctx.method,
+        path: ctx.path,
+        ...(typeof requestId === "string" ? { requestId } : {}),
+        error: redactSensitive(error),
+      });
+    };
+  }
+  return (_ctx, error) => console.error("[http] unhandled error:", redactSensitive(error));
+}
+
 function safelyReportUnexpected(
   options: ErrorHandlerOptions,
-  fallback: (error: unknown) => void,
+  log: ErrorLog,
   ctx: HttpContext,
   error: unknown,
 ): void {
@@ -43,13 +75,13 @@ function safelyReportUnexpected(
     options.onUnexpectedError?.(ctx, error);
   } catch (hookError) {
     try {
-      fallback(hookError);
+      log(ctx, hookError);
     } catch {
       // Logging hooks are best-effort; response safety is primary.
     }
   }
   try {
-    fallback(error);
+    log(ctx, error);
   } catch {
     // A broken sink must not escape the HTTP error boundary.
   }
@@ -61,7 +93,7 @@ function safelyReportUnexpected(
  * else becomes 500 Internal Server Error.
  */
 export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware {
-  const fallback = options.logError ?? ((error: unknown) => console.error("[http] unhandled error:", redactSensitive(error)));
+  const log = resolveErrorLog(options);
   return async (ctx, next) => {
     try {
       await next();
@@ -87,12 +119,14 @@ export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware
         );
         return;
       }
-      safelyReportUnexpected(options, fallback, ctx, error);
+      safelyReportUnexpected(options, log, ctx, error);
       ctx.response = options.exposeDetails
         ? safeJsonResponse(500, {
             error: "Internal Server Error",
-            message: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : undefined,
+            // Development only, but redacted like the log: a secret in an error
+            // message must not reach a browser or a shared screenshot.
+            message: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+            stack: error instanceof Error && error.stack !== undefined ? redactSensitiveText(error.stack) : undefined,
           })
         : safeJsonResponse(500, { error: "Internal Server Error" });
     }

package/core/http/SPEC.md

@@ -405,9 +405,10 @@ Exported from `bazis/core/http`. They are connected through `@Middleware(...)`,
 
 | `ErrorHandlerOptions` field | Type | Default | Description |
 | --- | --- | --- | --- |
-| `exposeDetails` | `boolean` | `httpModule({ exposeErrorDetails })` / environment | message/stack in 500 responses; never enable in production |
-| `onUnexpectedError` | `(ctx, error) => void` | DI `HTTP_ERROR_HOOK` hooks | called for non-`HttpError` failures |
-| `logError` | `(error) => void` | `console.error` | fallback when no hook handles the error |
+| `exposeDetails` | `boolean` | `httpModule({ exposeErrorDetails })` / environment | redacted message/stack in 500 responses; never enable in production |
+| `onUnexpectedError` | `(ctx, error) => void` | DI `HTTP_ERROR_HOOK` hooks | notification for non-`HttpError` failures (e.g. an error tracker); the error is still logged |
+| `logError` | `(error) => void` | — | replaces the built-in logging of unexpected errors |
+| `logger` | `Logger` | the application `LOGGER` | one `error` line: `"<METHOD> <path> failed"` with `method`, `path`, `requestId` and the redacted `error`; `console.error` when there is no logger |
 
 `HttpError` → JSON with its status; anything else → 500.
 

package/core/http/middlewareTokens.ts

@@ -31,8 +31,8 @@ export const ROUTE_MIDDLEWARE_COMPOSER = createToken<RouteMiddlewareComposerRegi
 
 /**
  * Hook invoked by the built-in error boundary on a non-{@link HttpError}
- * failure. Self-wiring: e.g. the logging module registers one to record the
- * error, keeping `@/core/http` free of logging imports. Collected via `resolveAll`.
+ * failure, for example to report it to an error tracker. It is a notification:
+ * the error is still logged and answered with 500. Collected via `resolveAll`.
  */
 export type HttpErrorHook = (ctx: HttpContext, error: unknown) => void;
 

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.97.1" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.97.0",
+  "version": "0.97.1",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",