@dunx/http 0.1.0 → 0.1.1

package/dist/route/metadata.d.ts

@@ -23,7 +23,7 @@ export declare const PUBLIC: MetaKey<boolean>;
 export declare const Roles: (...roles: readonly string[]) => <F extends object>(target: F) => F;
 export declare const Public: () => <F extends object>(target: F) => F;
 /**
- * Guards are middleware, so they compose rather than override — which is why they
+ * Guards are middleware, so they compose rather than override - which is why they
  * are not a `MetaKey`. Valid on a method or on a class.
  */
 export declare const UseGuards: (...guards: readonly Ctor<Middleware>[]) => <F extends object>(target: F) => F;

package/dist/route/schema.d.ts

@@ -31,7 +31,7 @@ export interface StandardSchemaIssue {
         readonly key: PropertyKey;
     })[] | undefined;
 }
-/** The validated output of a schema — `InferOutput<typeof CreateNote>` is `Note`. */
+/** The validated output of a schema - `InferOutput<typeof CreateNote>` is `Note`. */
 export type InferOutput<S> = S extends StandardSchemaV1<unknown, infer Out> ? Out : never;
 /**
  * The second argument to `@Get`/`@Post`/... Declaring a schema is what makes the
@@ -47,9 +47,9 @@ export interface RouteSchemas {
 }
 /**
  * The handler's parameter type, derived from its own options object. It has to be
- * written out — a standard method decorator can *check* a parameter's type but
+ * written out - a standard method decorator can *check* a parameter's type but
  * cannot contextually type an unannotated one (docs/ARCHITECTURE.md, "Verified
- * constraints") — but every field type still comes from the schemas, so nothing
+ * constraints") - but every field type still comes from the schemas, so nothing
  * is declared twice:
  *
  * ```ts

package/dist/server/application.d.ts

@@ -29,7 +29,7 @@ export interface HttpOptions extends AppOptions {
      */
     readonly websocket?: SocketOptions;
     /**
-     * Multi-node websocket fan-out. Absent — the default — means `PubSub` publishes
+     * Multi-node websocket fan-out. Absent - the default - means `PubSub` publishes
      * to this process only, which is exactly Bun's native pub/sub and costs nothing.
      *
      * `new RedisRelay({ url })` is the batteries-included one. Anything with a
@@ -43,7 +43,7 @@ export interface HttpOptions extends AppOptions {
 }
 /**
  * Everything below `listen()` configures the route table, which is built exactly
- * once — when the server binds. Calling any of them afterwards throws rather than
+ * once - when the server binds. Calling any of them afterwards throws rather than
  * being quietly dropped.
  */
 export interface HttpApp extends App {
@@ -55,7 +55,7 @@ export interface HttpApp extends App {
     setting<K extends keyof AppSettings>(key: K): AppSettings[K];
     /** Mounts an `OPTIONS` preflight per path. Last call wins. */
     enableCors(options?: CorsOptions): this;
-    /** The same `inject(ClientAddress)` singleton — honours `'trust proxy'`. */
+    /** The same `inject(ClientAddress)` singleton - honours `'trust proxy'`. */
     clientIp(req: BunRequest): string | undefined;
     /** Every gateway path this app upgrades on, exactly as mounted. */
     readonly gatewayPaths: readonly string[];
@@ -75,7 +75,7 @@ export declare class HttpApplication implements HttpApp {
     clientIp(req: BunRequest): string | undefined;
     /**
      * The one `Bun.serve` call. A gateway's upgrade is a native `GET` route in the
-     * same table, so Bun's router — not a hand-written `fetch` fallback — is what
+     * same table, so Bun's router - not a hand-written `fetch` fallback - is what
      * matches an upgrade, and no `fetch` handler is needed at all.
      */
     listen(port?: number): Promise<string>;

package/dist/server/context.d.ts

@@ -4,7 +4,7 @@ import type { MetaKey } from '../route/metadata.js';
 /**
  * Which route the middleware is running for, and what that route's decorators
  * declared. `get` resolves the handler's metadata first and the controller class's
- * second — the same override direction as Nest's `getAllAndOverride`.
+ * second - the same override direction as Nest's `getAllAndOverride`.
  */
 export interface RouteContext {
     readonly controller: string;
@@ -15,7 +15,7 @@ export interface RouteContext {
 }
 /**
  * One frozen context per route, built when the table is built and closed over by
- * the chain. The merge already happened at discovery, so `get` is a Map lookup —
+ * the chain. The merge already happened at discovery, so `get` is a Map lookup -
  * not a prototype walk, and nothing is read per request.
  */
 export declare const buildContext: (route: DiscoveredRoute) => RouteContext;

package/dist/server/cors.d.ts

@@ -3,7 +3,7 @@ export type CorsOrigin = string | readonly string[] | ((origin: string) => boole
 export interface CorsOptions {
     /**
      * `'*'` by default. A concrete string, a list, or a predicate all answer with the
-     * caller's own origin only when it is allowed — a request from anywhere else gets
+     * caller's own origin only when it is allowed - a request from anywhere else gets
      * no CORS headers at all, which is what makes the browser block it.
      */
     readonly origin?: CorsOrigin;
@@ -20,7 +20,7 @@ export interface CorsOptions {
 export declare const withCors: (options: CorsOptions, handler: RouteHandler) => RouteHandler;
 /**
  * `Bun.serve({ routes })` answers a method miss with 404, so a preflight cannot be
- * inferred — every CORS-enabled path gets its own `OPTIONS` handler, built at boot
+ * inferred - every CORS-enabled path gets its own `OPTIONS` handler, built at boot
  * from the methods that path actually declares.
  */
 export declare const preflight: (options: CorsOptions, methods: readonly string[]) => RouteHandler;

package/dist/server/errors.d.ts

@@ -13,7 +13,7 @@ export interface ValidationIssue {
 }
 /**
  * A declared schema rejected the input. Always a 400, and the issues survive into
- * the response body — a caller cannot fix what it cannot see.
+ * the response body - a caller cannot fix what it cannot see.
  */
 export declare class ValidationError extends HttpError {
     readonly source: InputSource;

package/dist/server/input.d.ts

@@ -2,11 +2,11 @@ import type { BunRequest } from 'bun';
 import type { RouteInput, RouteSchemas } from '../route/schema.js';
 /**
  * Built once per route at boot. A route that declares nothing gets the identity
- * reader — no parse, no validation, not even a promise.
+ * reader - no parse, no validation, not even a promise.
  *
  * A reader **returns a promise only when it has something to wait for**. A `body`
- * schema always does; `query` and `params` against a synchronous validator — which
- * zod, Valibot and ArkType all are — resolve without one.
+ * schema always does; `query` and `params` against a synchronous validator - which
+ * zod, Valibot and ArkType all are - resolve without one.
  */
 export type InputReader = (req: BunRequest) => RouteInput | Promise<RouteInput>;
 /**

package/dist/server/middleware.d.ts

@@ -4,7 +4,7 @@ export type Next = () => Promise<Response>;
 /**
  * The single extension point. A guard is middleware that throws, an interceptor
  * wraps `next()`, a filter is the error mapper. `ctx` names the route and carries
- * what its decorators declared, resolved at boot — so a guard costs a Map lookup.
+ * what its decorators declared, resolved at boot - so a guard costs a Map lookup.
  */
 export interface Middleware {
     handle(req: BunRequest, ctx: RouteContext, next: Next): Promise<Response>;
@@ -13,8 +13,8 @@ export type RouteHandler = (req: BunRequest) => Promise<Response>;
 /**
  * What goes into the `Bun.serve` route table. Wider than `RouteHandler` because
  * Bun accepts a plain `Response`, which is what lets a route with nothing to
- * await skip promises altogether — see `buildRoutes`.
+ * await skip promises altogether - see `buildRoutes`.
  */
 export type ServedHandler = (req: BunRequest) => Response | Promise<Response>;
-/** Folded into one closure per route at boot — no per-request array iteration. */
+/** Folded into one closure per route at boot - no per-request array iteration. */
 export declare const compose: (middleware: readonly Middleware[], ctx: RouteContext, handler: RouteHandler) => RouteHandler;

package/dist/server/request-logging.d.ts

@@ -9,7 +9,7 @@ export interface RequestLoggingOptions {
     /**
      * Log the request body. Default **`false`**.
      *
-     * Reading it means `req.clone().text()` — a second copy of every payload,
+     * Reading it means `req.clone().text()` - a second copy of every payload,
      * buffered and parsed, on the hot path. Measured on the `validate` scenario in
      * `tools/bench`, turning both body options on costs roughly two thirds of the
      * throughput. It is also the field most likely to contain a password.
@@ -17,17 +17,17 @@ export interface RequestLoggingOptions {
      * Turn it on in development, where seeing the payload is the point.
      */
     readonly requestBody?: boolean;
-    /** Log the response body. Default **`false`** — same clone-and-buffer cost. */
+    /** Log the response body. Default **`false`** - same clone-and-buffer cost. */
     readonly responseBody?: boolean;
-    /** Paths to skip entirely — a health check polled every second, say. */
+    /** Paths to skip entirely - a health check polled every second, say. */
     readonly ignore?: readonly string[];
 }
 /**
  * One structured entry per request, carrying the request and its response.
  *
  * Installed by `HttpFactory.create` unless `requestLogging: false`. It injects
- * `Logger` and `RequestContext` — both `@dunx/core` contracts, both bound by
- * default — so it works with no logging module imported, and picks up
+ * `Logger` and `RequestContext` - both `@dunx/core` contracts, both bound by
+ * default - so it works with no logging module imported, and picks up
  * `@arkv/logger` automatically once `@dunx/infra/logger` is.
  *
  * **One entry, not two.** Nest needs a middleware for the inbound half and an
@@ -42,7 +42,7 @@ export interface RequestLoggingOptions {
  *
  * **Nothing here is `async`.** Reading the request or the response body are the
  * only steps that can ever wait, both are off by default, and both are adopted
- * with `.then` rather than awaited — the same rule `input.ts` follows, for the
+ * with `.then` rather than awaited - the same rule `input.ts` follows, for the
  * same measured reason. An `async` scope callback alone cost 0.44 µs/request
  * against a synchronous one on raw `Bun.serve`.
  */

package/dist/server/routes.d.ts

@@ -7,7 +7,7 @@ import { type ErrorMapper } from './errors.js';
 import { type Middleware, type RouteHandler, type ServedHandler } from './middleware.js';
 /** How a `@UseGuards` class becomes an instance. `listen()` passes `app.get`. */
 export type GuardResolver = (guard: Ctor<Middleware>) => Middleware;
-/** `OPTIONS` is never a `@Get`-style route — only CORS mounts one. */
+/** `OPTIONS` is never a `@Get`-style route - only CORS mounts one. */
 export type RouteMethod = HttpMethod | 'OPTIONS';
 export type BunRoutes = Record<string, Partial<Record<RouteMethod, ServedHandler>>>;
 /**
@@ -28,12 +28,12 @@ export declare const assertNoCollisions: (discovered: readonly DiscoveredRoute[]
 export declare const assertNoGatewayCollisions: (discovered: readonly DiscoveredRoute[], gatewayPaths: readonly string[]) => void;
 /**
  * The two tables in one. A gateway's `GET` is what Bun's router matches on an
- * upgrade — the reason no `fetch` handler is needed for a socket to connect.
+ * upgrade - the reason no `fetch` handler is needed for a socket to connect.
  */
 export declare const withUpgradeRoutes: (routes: BunRoutes, gateways: ReadonlyMap<string, UpgradeHandler>) => ServeRoutes;
 /**
  * Bun answers an unmatched path itself, so nothing in the middleware chain ever
- * sees it — which makes a 404 invisible to request logging, metrics and tracing.
+ * sees it - which makes a 404 invisible to request logging, metrics and tracing.
  *
  * This is the only `fetch` handler dunx installs, and it is not a router: Bun
  * still does all the matching, and this runs only once Bun has decided nothing

package/dist/server/settings.d.ts

@@ -1,6 +1,6 @@
 /**
  * The settings `app.set()` accepts. A key has to be declared here to be settable,
- * so the map is checked at compile time instead of being a string bag — a typo is
+ * so the map is checked at compile time instead of being a string bag - a typo is
  * a type error, not a setting that silently never applies.
  */
 export interface AppSettings {

package/dist/server/status.d.ts

@@ -1,6 +1,6 @@
 /**
  * Frozen object plus an indexed-access union, not an `enum`. An enum emits a
- * runtime object that no other syntax can produce, which is why the repo bans it —
+ * runtime object that no other syntax can produce, which is why the repo bans it -
  * see CLAUDE.md. This gives the same `HttpStatusCode.NOT_FOUND` ergonomics, a
  * narrower type, and erases cleanly.
  */

package/dist/ws/discover.d.ts

@@ -34,7 +34,7 @@ export declare const discoverGateway: (instance: object) => DiscoveredGateway;
 export declare const findHandlerMethod: (ctor: Ctor<unknown>) => string | undefined;
 /**
  * Gateways are declared in `@Module({ providers })` like any other injectable and
- * found here by their marker — the same discovery-by-inspection controllers get,
+ * found here by their marker - the same discovery-by-inspection controllers get,
  * with no second registration key to keep in step.
  */
 export declare const discoverGateways: (modules: readonly ResolvedModule[], resolve: (token: InjectionToken<unknown>) => unknown) => readonly DiscoveredGateway[];

package/dist/ws/envelope.d.ts

@@ -1,7 +1,7 @@
 /**
  * The whole wire protocol: one JSON object, an event name, and a payload. It is
  * only ever read for a gateway that declares at least one `@OnMessage(event)`
- * handler — a gateway with only a raw `@OnMessage()` never parses anything.
+ * handler - a gateway with only a raw `@OnMessage()` never parses anything.
  */
 export interface Envelope {
     readonly event: string;
@@ -9,7 +9,7 @@ export interface Envelope {
 }
 export declare const encode: (event: string, data: unknown) => string;
 /**
- * `undefined` for anything that is not an envelope — binary frames, invalid JSON,
+ * `undefined` for anything that is not an envelope - binary frames, invalid JSON,
  * a non-object, or a missing `event`. Those fall through to the raw handler
  * instead of being rejected here.
  */

package/dist/ws/pubsub.d.ts

@@ -6,11 +6,11 @@ import type { SocketData } from './socket.js';
  * runtime, not in a JavaScript registry: `socket.subscribe(topic)` is what joins
  * one, and Bun does the fan-out.
  *
- * Injectable — `HttpFactory` binds it, so a service can publish without holding a
+ * Injectable - `HttpFactory` binds it, so a service can publish without holding a
  * socket and without registering anything.
  *
  * With a {@link PubSubRelay} attached the same publish also reaches the other
- * nodes. Without one — the default — nothing here touches a broker and the cost is
+ * nodes. Without one - the default - nothing here touches a broker and the cost is
  * exactly Bun's.
  */
 export declare class PubSub {
@@ -25,12 +25,12 @@ export declare class PubSub {
      * Opt into multi-node fan-out: every `publish` from here on also goes to
      * `relay`, and everything other nodes put on the channel is fanned out locally.
      *
-     * `HttpFactory.create(root, { relay })` is the shorthand — `listen()` calls this.
+     * `HttpFactory.create(root, { relay })` is the shorthand - `listen()` calls this.
      * Call it directly when the relay has to come out of the container, which is the
      * case for an app reusing its own `@dunx/infra/redis` connection:
      * `app.get(PubSub).relayThrough(app.get(RedisConnection))` before `listen()`.
      *
-     * A broker that cannot be reached is reported through `onError` and left alone —
+     * A broker that cannot be reached is reported through `onError` and left alone -
      * local fan-out is unaffected, and the app boots either way.
      */
     relayThrough(relay: PubSubRelay, options?: RelayOptions): Promise<void>;

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

@@ -10,7 +10,7 @@ export interface RedisRelayOptions {
      * `0` by default, and that default is not a preference: a `Bun.RedisClient` that
      * never connects keeps an internal retry timer alive past `close()`, and the
      * process then never exits. A relay is exactly the connection most likely to be
-     * absent — a single-node deployment with `REDIS_URL` left over from staging —
+     * absent - a single-node deployment with `REDIS_URL` left over from staging -
      * so the default has to be the one that lets the app boot, degrade, and still
      * exit. Raise it when Redis is a hard requirement and you want Bun to reconnect
      * for you.
@@ -23,7 +23,7 @@ export interface RedisRelayOptions {
     readonly tls?: boolean | Bun.TLSOptions;
 }
 /**
- * A {@link PubSubRelay} on `Bun.RedisClient` — a Bun global, so this costs
+ * A {@link PubSubRelay} on `Bun.RedisClient` - a Bun global, so this costs
  * `@dunx/http` no dependency at all.
  *
  * **Two connections, not one.** A client in subscriber mode rejects every data

package/dist/ws/relay.d.ts

@@ -1,7 +1,7 @@
 /**
  * What `PubSub` needs from something that carries a message to the other nodes:
  * publish, and subscribe. Nothing else, so anything that already talks to a
- * broker satisfies it — `@dunx/infra/redis`'s `RedisConnection` does, structurally
+ * broker satisfies it - `@dunx/infra/redis`'s `RedisConnection` does, structurally
  * and with no adapter, and so does a bare `Bun.RedisClient` pair.
  *
  * The return types are `unknown` rather than `Promise<void>` deliberately: Bun's
@@ -15,7 +15,7 @@ export interface PubSubRelay {
     publish(channel: string, message: string): unknown;
     /**
      * Deliver every message published to `channel` to `listener`. Called once, with
-     * one channel — pattern subscription is not used, because Bun's `psubscribe`
+     * one channel - pattern subscription is not used, because Bun's `psubscribe`
      * does not work (see docs/bun-apis.md).
      */
     subscribe(channel: string, listener: (message: string) => void): unknown;
@@ -34,7 +34,7 @@ export interface RelayOptions {
      * The one broker channel every topic's frames travel on.
      *
      * One channel rather than one per topic, because a node cannot know which
-     * topics its sockets joined — `socket.subscribe()` goes straight into Bun — and
+     * topics its sockets joined - `socket.subscribe()` goes straight into Bun - and
      * `psubscribe` is unusable. The cost is that every node reads every relayed
      * frame and drops the ones for topics it has no local subscriber on, which is a
      * `server.publish` returning `0`. Two apps sharing a Redis need two channels.
@@ -50,8 +50,8 @@ export interface RelayOptions {
      */
     readonly onError?: (error: unknown, phase: RelayPhase) => void;
     /**
-     * What to do when the **boot** subscribe fails. Publishing recovers on its own —
-     * every publish retries the broker — but a failed subscribe used to be retried
+     * What to do when the **boot** subscribe fails. Publishing recovers on its own -
+     * every publish retries the broker - but a failed subscribe used to be retried
      * by nothing, so the node stayed permanently deaf to other nodes while still
      * looking healthy.
      *
@@ -69,7 +69,7 @@ export declare const DEFAULT_RELAY_CHANNEL = "dunx:ws";
 export declare const defaultRelayError: (error: unknown, phase: RelayPhase) => void;
 /**
  * One relayed publish: which process published it, which topic it belongs to, and
- * the frame itself. `origin` is the whole duplicate-delivery defence — the broker
+ * the frame itself. `origin` is the whole duplicate-delivery defence - the broker
  * echoes a publish back to the publisher, and fanning that out locally a second
  * time would give every client on the originating node the message twice.
  */

package/dist/ws/runtime.d.ts

@@ -1,7 +1,7 @@
 import type { DiscoveredGateway, Invoke } from './discover.js';
 /**
  * One gateway reduced to direct references, built once at boot. Dispatch reads
- * these fields and nothing else — no lookup, no metadata, no DI per message.
+ * these fields and nothing else - no lookup, no metadata, no DI per message.
  */
 export interface GatewayRuntime {
     readonly name: string;

package/dist/ws/socket.d.ts

@@ -10,7 +10,7 @@ export interface SocketData<T = unknown> {
 }
 /**
  * Bun's native socket, unwrapped. `send`, `subscribe`, `unsubscribe`,
- * `isSubscribed`, `publish`, `cork` and `close` are its own methods — nothing here
+ * `isSubscribed`, `publish`, `cork` and `close` are its own methods - nothing here
  * reimplements them.
  */
 export type Socket<T = unknown> = ServerWebSocket<SocketData<T>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -13,7 +13,7 @@
     "websocket"
   ],
   "homepage": "https://github.com/petarzarkov/dunx/tree/main/packages/http#readme",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": {
     "name": "Petar Zarkov",
     "email": "pzarko1@gmail.com",
@@ -51,7 +51,7 @@
     "@dunx/core": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "0.1.0",
+    "@dunx/core": "0.1.1",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {