bazis 0.98.10 → 0.98.11

package/core/http/Middleware/errorHandler.ts

@@ -1,5 +1,6 @@
 import { REQUEST_ID_STATE_KEY, type Logger } from "../../kernel";
 import { redactSensitive, redactSensitiveText } from "../../../library/redaction";
+import { HttpClientError, HttpErrorCode } from "../../../library/http-client/errors";
 import type { HttpContext } from "../HttpContext/HttpContext";
 import { HttpError } from "../Errors/HttpError";
 import type { HttpMiddleware } from "./types";
@@ -124,15 +125,30 @@ export function errorHandler(options: ErrorHandlerOptions = {}): HttpMiddleware
         return;
       }
       safelyReportUnexpected(options, log, ctx, error);
+      const [status, title] = unexpectedStatus(error);
       ctx.response = options.exposeDetails
-        ? safeJsonResponse(500, {
-            error: "Internal Server Error",
+        ? safeJsonResponse(status, {
+            error: title,
             // 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" });
+        : safeJsonResponse(status, { error: title });
     }
   };
 }
+
+/**
+ * An unhandled outbound HTTP failure is the upstream's fault, not ours:
+ * 504 when the call timed out, 502 otherwise. A client error without a code
+ * is a misconfiguration of our request (for example an invalid maxRedirects)
+ * and stays 500, like everything else. Upstream details never reach the
+ * client; the log keeps the full error.
+ */
+function unexpectedStatus(error: unknown): readonly [number, string] {
+  if (error instanceof HttpClientError && error.code !== undefined) {
+    return error.code === HttpErrorCode.Timeout ? [504, "Gateway Timeout"] : [502, "Bad Gateway"];
+  }
+  return [500, "Internal Server Error"];
+}

package/core/http-client/index.ts

@@ -16,8 +16,8 @@ import { DI, Module, createToken, type BazisModule, type ProviderDefinition } fr
 import { getOutboundCorrelationHeaders } from "../kernel";
 import {
   HttpClient,
+  HttpClientFactory,
   HttpClientFactoryBuilder,
-  type HttpClientFactory,
   type HeaderBag,
   type RequestConfig,
 } from "../../library/http-client";
@@ -44,9 +44,10 @@ export interface HttpClientModuleConfig {
 
 /**
  * Registers the outbound HTTP client in DI with correlation propagation wired
- * to the kernel request context:
- * - {@link HTTP_CLIENT_FACTORY} — named clients (fail-fast on unknown names);
- * - {@link HTTP_CLIENT} — the default injectable {@link HttpClient}.
+ * to the kernel request context. A service takes it by type:
+ * - `HttpClient` (or the {@link HTTP_CLIENT} token) — the default client;
+ * - `HttpClientFactory` (or {@link HTTP_CLIENT_FACTORY}) — named clients
+ *   (fail-fast on unknown names).
  */
 export function httpClientModule(config: HttpClientModuleConfig = {}): BazisModule {
   const correlationHeaders = config.correlationHeaders ?? getOutboundCorrelationHeaders;
@@ -83,11 +84,14 @@ export function httpClientModule(config: HttpClientModuleConfig = {}): BazisModu
   }
   const factory = builder.build();
 
+  const client = factory.createClient();
+  // One factory and one default client, under the class (injection by type)
+  // and under the original tokens.
   const providers: ProviderDefinition[] = [
+    DI.singleton(DI.valueProvider(HttpClientFactory, factory)),
     DI.singleton(DI.valueProvider(HTTP_CLIENT_FACTORY, factory)),
-    DI.singleton(
-      DI.factoryProvider(HTTP_CLIENT, [HTTP_CLIENT_FACTORY], (resolved: HttpClientFactory) => resolved.createClient()),
-    ),
+    DI.singleton(DI.valueProvider(HttpClient, client)),
+    DI.singleton(DI.valueProvider(HTTP_CLIENT, client)),
   ];
 
   @Module({ providers })

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.98.10" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.11" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/http-client/HttpClient.ts

@@ -6,7 +6,9 @@ import {
   appendQuery,
   basicAuthHeader,
   isBodyInit,
+  isAbsoluteUrl,
   mergeHeaderBags,
+  pageUrl,
   resolveUrl,
   shouldPropagateCorrelation,
 } from "./serialize";
@@ -188,7 +190,8 @@ export class HttpClient {
     return { ...merged, method: String(override.method ?? base.method ?? "GET").toUpperCase() };
   }
 
-  private async dispatch<T>(config: ResolvedRequestConfig): Promise<HttpResponse<T>> {
+  private async dispatch<T>(requested: ResolvedRequestConfig): Promise<HttpResponse<T>> {
+    const config = withAbsoluteBaseUrl(requested);
     if (config.inspectableRedirects !== undefined && typeof config.inspectableRedirects !== "boolean") {
       throw new HttpClientError("inspectableRedirects must be a boolean", { config });
     }
@@ -650,6 +653,26 @@ function isReplayableBody(body: RequestInit["body"]): boolean {
     || (typeof ReadableStream !== "undefined" && body instanceof ReadableStream));
 }
 
+/**
+ * A relative `baseUrl` (`"/api"`) is resolved against the page address once,
+ * so URL building and every origin check below see an absolute base. Outside
+ * a page there is nothing to resolve it against.
+ */
+function withAbsoluteBaseUrl(config: ResolvedRequestConfig): ResolvedRequestConfig {
+  const { baseUrl } = config;
+  if (!baseUrl || isAbsoluteUrl(baseUrl)) {
+    return config;
+  }
+  const page = pageUrl();
+  if (page === undefined) {
+    throw new HttpClientError(
+      `baseUrl "${baseUrl}" is relative: outside a browser page it must be absolute, for example "http://localhost:3000${baseUrl.startsWith("/") ? "" : "/"}${baseUrl}"`,
+      { config },
+    );
+  }
+  return { ...config, baseUrl: new URL(baseUrl, page).toString() };
+}
+
 function sameOrigin(left: string, right: string): boolean {
   try {
     return new URL(left).origin === new URL(right).origin;

package/library/http-client/HttpClientFactory.ts

@@ -2,9 +2,32 @@ import { HttpClient } from "./HttpClient";
 import { HttpClientConfigError } from "./errors";
 import type { RequestConfig } from "./types";
 
-/** Resolves pre-configured named clients (à la .NET `IHttpClientFactory`). */
-export interface HttpClientFactory {
-  createClient(name?: string): HttpClient;
+/**
+ * Resolves pre-configured named clients (à la .NET `IHttpClientFactory`).
+ * An abstract class, so a service can take it by type in its constructor.
+ */
+export abstract class HttpClientFactory {
+  public abstract createClient(name?: string): HttpClient;
+}
+
+class ConfiguredHttpClientFactory extends HttpClientFactory {
+  public constructor(
+    private readonly defaults: RequestConfig,
+    private readonly named: ReadonlyMap<string, RequestConfig>,
+  ) {
+    super();
+  }
+
+  public createClient(name?: string): HttpClient {
+    if (name === undefined) {
+      return new HttpClient(this.defaults);
+    }
+    const config = this.named.get(name);
+    if (config === undefined) {
+      throw new HttpClientConfigError(name, [...this.named.keys()]);
+    }
+    return new HttpClient(this.defaults).create(config);
+  }
 }
 
 /**
@@ -27,19 +50,6 @@ export class HttpClientFactoryBuilder {
   }
 
   public build(): HttpClientFactory {
-    const named = new Map(this.named);
-    const defaults = this.defaults;
-    return {
-      createClient(name?: string): HttpClient {
-        if (name === undefined) {
-          return new HttpClient(defaults);
-        }
-        const config = named.get(name);
-        if (config === undefined) {
-          throw new HttpClientConfigError(name, [...named.keys()]);
-        }
-        return new HttpClient(defaults).create(config);
-      },
-    };
+    return new ConfiguredHttpClientFactory(this.defaults, new Map(this.named));
   }
 }

package/library/http-client/index.ts

@@ -12,7 +12,7 @@
  */
 export { HttpClient } from "./HttpClient";
 export { InspectableRedirectProtocol } from "./redirectProtocol";
-export { HttpClientFactoryBuilder, type HttpClientFactory } from "./HttpClientFactory";
+export { HttpClientFactoryBuilder, HttpClientFactory } from "./HttpClientFactory";
 export { HttpClientError, HttpClientConfigError, HttpErrorCode } from "./errors";
 export { InterceptorManager, type FulfilledFn, type RejectedFn } from "./interceptors";
 export {

package/library/http-client/serialize.ts

@@ -8,6 +8,20 @@ const ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:\/\//i;
  * prefix), `baseUrl: "https://api/v1"` + `"/users"` → `…/v1/users`.
  * Absolute URLs and missing baseUrl pass through.
  */
+export function isAbsoluteUrl(url: string): boolean {
+  return ABSOLUTE_URL.test(url);
+}
+
+/**
+ * The address of the current page in a browser (or worker), else undefined.
+ * A relative `baseUrl` such as `"/api"` is resolved against it, like axios's
+ * `baseURL` in a browser app.
+ */
+export function pageUrl(): string | undefined {
+  const location = (globalThis as { location?: { href?: unknown } }).location;
+  return typeof location?.href === "string" ? location.href : undefined;
+}
+
 export function resolveUrl(baseUrl: string | undefined, url: string): string {
   if (!baseUrl || ABSOLUTE_URL.test(url)) {
     return url;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.98.10",
+  "version": "0.98.11",
   "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",