@dunx/http 3.2.0 → 3.2.1

package/dist/inspect.d.ts

@@ -1,4 +1,13 @@
 import { type Dependency, type ModuleRef } from '@dunx/core';
+/**
+ * Routes and gateways read off the module graph, constructing nothing. The
+ * traversal is `@dunx/core`'s; here is the half needing this package's metadata -
+ * route markers, guards, `@Roles`/`@Public`, the gateway marker.
+ *
+ * `discoverRoutes` walks a prototype chain, and
+ * `Object.create(Controller.prototype)` is that chain with nothing behind it, so
+ * no constructor or dependency of one has to exist.
+ */
 export interface RouteInputs {
     readonly body?: string;
     readonly query?: string;

package/dist/internal.d.ts

@@ -3,34 +3,17 @@
  *
  * The barrel was a semver promise 173 symbols wide, which is more than this
  * package meant to make. What stays public there is the surface an app writes
- * against:
- * decorators, options, contracts, errors, modules and the metadata helpers a
- * user's own guard reads. What is here is route-table construction, the
- * middleware fold, the relay codec and the discovery readers - things
- * `@dunx/dashboard`, `@dunx/mcp` and `@dunx/openapi` need and an app does not.
+ * against. What is here is the discovery readers and route metadata that
+ * `@dunx/dashboard`, `@dunx/mcp`, `@dunx/openapi` and `@dunx/testing` import.
+ *
+ * It held 62 symbols and 50 had no importer, all of them reachable from inside
+ * this package by relative import. Add one back when a sibling needs it.
  *
  * No stability promise attaches to this subpath.
  */
 export { discoverRoutes, joinPath, type DiscoveredRoute, } from './route/discover.js';
-export { defaultStatusFor, type DefaultStatus, type RouteMeta, } from './route/marker.js';
-export { guardsOf } from './route/metadata.js';
+export { defaultStatusFor } from './route/marker.js';
 export { gatewaysOf, routesOf, type GatewayHandler, type GatewayNode, type RouteInputs, type RouteNode, } from './inspect.js';
 export { buildContext } from './server/context.js';
-export { preflight, withCors } from './server/cors.js';
-export { isErrorFilter, toErrorMapper } from './server/errors.js';
-export { compose } from './server/middleware.js';
-export { assertNoCollisions, assertNoGatewayCollisions, buildRoutes, withUpgradeRoutes, type BunRoutes, type GuardResolver, type RouteMethod, type ServeRoutes, } from './server/routes.js';
-export { normalizePrefix } from './static/options.js';
-export { negotiate } from './compression/negotiate.js';
-export { isCompressibleType } from './compression/options.js';
-export { buildWebSocket, type UpgradeHandler, type WebSocketRuntime, } from './ws/adapter.js';
-export { discoverGateway, discoverGateways, normalizePath, type DiscoveredGateway, type DiscoveredHandler, type Invoke, } from './ws/discover.js';
-export { decode, encode } from './ws/envelope.js';
-export { composeSocket, observe } from './ws/middleware.js';
-export { HandlerKind, isGateway, type HandlerMeta } from './ws/marker.js';
-export { defaultRelayUrl } from './ws/redis-relay.js';
-export { decodeRelay, encodeRelay, type RelayFrame, type RelayPhase, } from './ws/relay.js';
-export { buildGateways, buildRuntime, type GatewayRuntime, } from './ws/runtime.js';
-export { HiddenHealthController } from './health/controller.js';
-export { backoffDelay, executeWithRetry, isRetryableStatus, retryAfterMs, } from './client/retry.js';
-export { isJsonBody, isPlainObject, safeStringify } from './client/json.js';
+export { embedJson } from './server/html.js';
+export { isGateway } from './ws/marker.js';

package/dist/internal.js

@@ -1,56 +1,22 @@
 // @bun
 import {
   HIDDEN,
-  HandlerKind,
-  HiddenHealthController,
   PUBLIC,
   ROLES,
-  assertNoCollisions,
-  assertNoGatewayCollisions,
   buildContext,
-  buildGateways,
-  buildRoutes,
-  buildRuntime,
-  buildWebSocket,
-  compose,
-  composeSocket,
-  decode,
-  decodeRelay,
-  defaultRelayUrl,
   defaultStatusFor,
   discoverGateway,
-  discoverGateways,
   discoverRoutes,
-  encode,
-  encodeRelay,
-  guardsOf,
-  isCompressibleType,
-  isErrorFilter,
   isGateway,
-  joinPath,
-  negotiate,
-  normalizePath,
-  normalizePrefix,
-  observe,
-  preflight,
-  toErrorMapper,
-  withCors,
-  withUpgradeRoutes
-} from "./chunk-y85wcdhw.js";
-import {
-  backoffDelay,
-  executeWithRetry,
-  isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
-  retryAfterMs,
-  safeStringify
-} from "./chunk-e8a9c6j2.js";
-import"./chunk-9x3evk19.js";
+  joinPath
+} from "./chunk-3nbj06q8.js";
+import"./chunk-sz4pvqxy.js";
 // src/inspect.ts
 import {
+  classOf,
   collectModules,
   dependenciesOf,
+  inertInstance,
   readControllers
 } from "@dunx/core";
 var vendorOf = (schema) => schema?.["~standard"]?.vendor;
@@ -85,11 +51,10 @@ var nodeFor = (route, module) => ({
   responses: Object.keys(route.options?.response ?? {}).map(Number)
 });
 var routesOf = (root) => collectModules(root).flatMap((module) => readControllers(module).flatMap((controller) => {
-  const { prototype } = controller;
-  return discoverRoutes(Object.create(prototype)).map((route) => nodeFor(route, module.name));
+  return discoverRoutes(inertInstance(controller)).map((route) => nodeFor(route, module.name));
 }));
 var gatewayFor = (ctor, module) => {
-  const { name, path, handlers } = discoverGateway(Object.create(ctor.prototype));
+  const { name, path, handlers } = discoverGateway(inertInstance(ctor));
   return {
     name,
     path,
@@ -102,53 +67,16 @@ var gatewayFor = (ctor, module) => {
     }))
   };
 };
-var classOf = (entry) => {
-  if (typeof entry === "function")
-    return entry;
-  return entry.provider.kind === "class" ? entry.provider.ctor : undefined;
-};
-var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map(classOf).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
+var gatewaysOf = (root) => collectModules(root).flatMap((module) => (module.options.providers ?? []).map((entry) => classOf(entry)?.ctor).filter((ctor) => ctor !== undefined).filter(isGateway).map((ctor) => gatewayFor(ctor, module.name)));
+// src/server/html.ts
+var embedJson = (value) => JSON.stringify(value).replaceAll("<", "\\u003c");
 export {
-  HandlerKind,
-  HiddenHealthController,
-  assertNoCollisions,
-  assertNoGatewayCollisions,
-  backoffDelay,
   buildContext,
-  buildGateways,
-  buildRoutes,
-  buildRuntime,
-  buildWebSocket,
-  compose,
-  composeSocket,
-  decode,
-  decodeRelay,
-  defaultRelayUrl,
   defaultStatusFor,
-  discoverGateway,
-  discoverGateways,
   discoverRoutes,
-  encode,
-  encodeRelay,
-  executeWithRetry,
+  embedJson,
   gatewaysOf,
-  guardsOf,
-  isCompressibleType,
-  isErrorFilter,
   isGateway,
-  isJsonBody,
-  isPlainObject,
-  isRetryableStatus,
   joinPath,
-  negotiate,
-  normalizePath,
-  normalizePrefix,
-  observe,
-  preflight,
-  retryAfterMs,
-  routesOf,
-  safeStringify,
-  toErrorMapper,
-  withCors,
-  withUpgradeRoutes
+  routesOf
 };

package/dist/server/application.d.ts

@@ -1,5 +1,5 @@
 import type { BunRequest } from 'bun';
-import { type App, type AppOptions, type Ctor, type InjectionToken, type ModuleRef, type ShutdownHookOptions, type ShutdownSignal } from '@dunx/core';
+import { ShutdownAware, type App, type AppOptions, type Ctor, type InjectionToken, type ModuleRef, type ShutdownHookOptions, type ShutdownSignal } from '@dunx/core';
 import { type DiscoveredRoute } from '../route/discover.js';
 import type { WebSocketRuntime } from '../ws/adapter.js';
 import type { SocketLoggingOptions } from '../ws/logging.js';
@@ -120,7 +120,7 @@ export interface HttpApp extends App {
     readonly gatewayPaths: readonly string[];
     listen(port?: number): Promise<string>;
 }
-export declare class HttpApplication implements HttpApp {
+export declare class HttpApplication extends ShutdownAware implements HttpApp {
     #private;
     /** Forwarded from the container so an app can log scope warnings at boot. */
     readonly warnings: readonly string[];
@@ -146,5 +146,4 @@ export declare class HttpApplication implements HttpApp {
      * `closed` unresolved; failures are collected and thrown at the end.
      */
     shutdown(): Promise<void>;
-    enableShutdownHooks(signals?: readonly ShutdownSignal[], options?: ShutdownHookOptions): this;
 }

package/dist/server/html.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Serialise a value for a `<script type="application/json">` block.
+ *
+ * `<` is the only character that can end the data block early, and escaping it as
+ * `\u003c` keeps the text valid JSON - the parser sees the same document either
+ * way. `@dunx/dashboard` and `@dunx/openapi` both inline a model into a page they
+ * serve, and both had a copy of this; if the escaping ever proves insufficient,
+ * one fix should cover both pages.
+ */
+export declare const embedJson: (value: unknown) => string;

package/dist/ws/decorators.d.ts

@@ -1,5 +1,5 @@
+import type { HandlerMethod } from '@dunx/core';
 type GatewayTarget = abstract new (...args: never[]) => object;
-type HandlerMethod = (...args: never[]) => unknown;
 export declare const Gateway: (path?: string) => <T extends GatewayTarget>(target: T) => T;
 /** Runs before the socket exists. Return a `Response` to refuse the upgrade. */
 export declare const OnUpgrade: () => <T extends HandlerMethod>(value: T) => T;

package/dist/ws/postgres-relay.d.ts

@@ -1,6 +1,4 @@
 import { WsRelay } from './relay.js';
-/** The same fallback chain `Bun.SQL` uses when given no URL. */
-export declare const defaultPostgresRelayUrl: () => string;
 export interface PostgresRelayOptions {
     /** @default `$POSTGRES_URL`, `$DATABASE_URL`, then `postgres://localhost:5432` */
     readonly url?: string;

package/dist/ws/relay.d.ts

@@ -27,6 +27,14 @@ export interface PubSubRelay {
      */
     close?(): unknown;
 }
+/**
+ * Both relays take a URL, and a wrong scheme has to fail here rather than at
+ * connect time: an absence-tolerant relay swallows the connection error, so a
+ * typo would degrade silently to single-node fan-out.
+ */
+export declare const assertRelayUrl: (url: string, protocols: readonly string[], example: string) => string;
+/** The URL with any password removed, for logs and error messages. */
+export declare const redactUrl: (url: string) => string;
 /** Which relay call failed, so one message can say what degraded. */
 export type RelayPhase = 'publish' | 'subscribe' | 'close';
 export interface RelayOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -65,7 +65,7 @@
     "@opentelemetry/sdk-trace-node": "2.11.0"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.2.0",
+    "@dunx/core": "^3.2.1",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {

package/dist/chunk-e8a9c6j2.js

@@ -1,130 +0,0 @@
-// @bun
-import {
-  HttpStatusCode
-} from "./chunk-9x3evk19.js";
-
-// src/client/errors.ts
-import { AppError } from "@dunx/core";
-
-class FetchError extends AppError {
-  status;
-  statusText;
-  body;
-  response;
-  name = "FetchError";
-  constructor(status, statusText, body, response) {
-    super(`HTTP ${status} ${statusText} from ${response.method} ${response.url}`);
-    this.status = status;
-    this.statusText = statusText;
-    this.body = body;
-    this.response = response;
-  }
-}
-Object.defineProperty(FetchError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "override readonly status: number" }, { unresolved: "readonly statusText: string" }, { unresolved: "readonly body: unknown" }, { unresolved: `readonly response: {
-      readonly method: string;
-      readonly url: string;
-      readonly headers: Headers;
-    }` }] });
-
-class FetchTransportError extends AppError {
-  response;
-  aborted;
-  name = "FetchTransportError";
-  constructor(response, aborted, options) {
-    super(`${response.method} ${response.url} failed: ${aborted ? "aborted" : "transport error"}`, options);
-    this.response = response;
-    this.aborted = aborted;
-  }
-}
-Object.defineProperty(FetchTransportError, Symbol.for("dunx.deps"), { value: () => [{ unresolved: "readonly response: { readonly method: string; readonly url: string }" }, { unresolved: "readonly aborted: boolean" }, ErrorOptions] });
-
-// src/client/json.ts
-var safeStringify = (value) => {
-  const seen = new WeakSet;
-  return JSON.stringify(value, (_key, entry) => {
-    if (typeof entry === "object" && entry !== null) {
-      if (seen.has(entry))
-        return "[Circular]";
-      seen.add(entry);
-    }
-    return entry;
-  });
-};
-var isPlainObject = (value) => {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var isJsonBody = (payload) => {
-  if (payload === null || payload === undefined)
-    return false;
-  if (typeof payload !== "object")
-    return typeof payload !== "string";
-  return !(payload instanceof FormData || payload instanceof URLSearchParams || payload instanceof Blob || payload instanceof ArrayBuffer || payload instanceof ReadableStream || ArrayBuffer.isView(payload));
-};
-
-// src/client/retry.ts
-var uniform = () => {
-  const buffer = new Uint32Array(1);
-  crypto.getRandomValues(buffer);
-  return (buffer[0] ?? 0) / 2 ** 32;
-};
-var backoffDelay = (attempt, { baseMs, power = 2, jitterMs = 1000, maxMs = 30000 }) => Math.min(baseMs * power ** attempt + uniform() * jitterMs, maxMs);
-var retryAfterMs = (headers, now = Date.now()) => {
-  const header = headers.get("retry-after");
-  if (header === null)
-    return;
-  const seconds = Number(header);
-  if (Number.isFinite(seconds))
-    return Math.max(0, seconds * 1000);
-  const at = Date.parse(header);
-  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
-};
-var isRetryableStatus = (status) => status >= HttpStatusCode.INTERNAL_SERVER_ERROR || status === HttpStatusCode.REQUEST_TIMEOUT || status === HttpStatusCode.TOO_MANY_REQUESTS;
-var decide = (error, attempt, options) => {
-  const {
-    retryDelayMs = 1000,
-    backoff,
-    shouldRetryOnStatus = isRetryableStatus,
-    respectRetryAfter = true
-  } = options;
-  const computed = backoffDelay(attempt, { baseMs: retryDelayMs, ...backoff });
-  if (error instanceof FetchTransportError) {
-    return { retry: !error.aborted, delayMs: computed };
-  }
-  if (error instanceof FetchError) {
-    if (!shouldRetryOnStatus(error.status))
-      return { retry: false, delayMs: 0 };
-    const asked = respectRetryAfter ? retryAfterMs(error.response.headers) : undefined;
-    const maxMs = backoff?.maxMs ?? 30000;
-    return {
-      retry: true,
-      delayMs: asked === undefined ? computed : Math.min(asked, maxMs)
-    };
-  }
-  return { retry: true, delayMs: computed };
-};
-var executeWithRetry = async (operation, options = {}) => {
-  const { maxRetries = 3, onAttempt, onError, onSuccess } = options;
-  let lastError;
-  for (let attempt = 0;attempt <= maxRetries; attempt += 1) {
-    onAttempt?.(attempt + 1, attempt > 0);
-    try {
-      const result = await operation();
-      onSuccess?.(result, attempt + 1);
-      return result;
-    } catch (error) {
-      lastError = error;
-      const { retry, delayMs } = decide(error, attempt, options);
-      const willRetry = retry && attempt < maxRetries;
-      onError?.(error, attempt + 1, willRetry);
-      if (!willRetry)
-        throw error;
-      await Bun.sleep(delayMs);
-    }
-  }
-  throw lastError;
-};
-
-export { FetchError, FetchTransportError, safeStringify, isPlainObject, isJsonBody, backoffDelay, retryAfterMs, isRetryableStatus, executeWithRetry };