@dunx/http 3.0.1 → 3.0.2

package/dist/client/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider, type Token } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig, type Token } from '@dunx/core';
 import { type HttpClientOptionsInit } from './options.js';
 import { HttpService } from './service.js';
 /**
@@ -57,5 +57,5 @@ export declare class HttpModule {
      * token has to exist before the factory runs.
      */
     static forRootAsync(load: () => HttpClientOptionsInit | Promise<HttpClientOptionsInit>, name?: string): DynamicModule;
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<HttpClientOptionsInit, D>, name?: string): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<HttpClientOptionsInit, D>, name?: string): DynamicModule;
 }

package/dist/client.js

@@ -292,11 +292,12 @@ var serviceFrom = (target, optionsToken) => provide(target, {
   useFactory: (options, logger, context) => new HttpService(options, logger, context),
   inject: [optionsToken, Logger2, RequestContext2]
 });
-var namedModule = (name, options) => {
+var namedModule = (name, options, imports = []) => {
   const optionsToken = token(`HttpClientOptions(${name})`);
   const optionsProvider = options instanceof HttpClientOptions ? provide(optionsToken, { useValue: options }) : provide(optionsToken, options);
   return {
     module: HttpModule,
+    imports,
     exports: [optionsToken, httpClient(name)],
     providers: [optionsProvider, serviceFrom(httpClient(name), optionsToken)]
   };
@@ -319,12 +320,14 @@ class HttpModule {
   static forRootAsync(source, name) {
     const load = typeof source === "function" ? source : source.useFactory;
     const inject = typeof source === "function" ? [] : source.inject ?? [];
+    const imports = typeof source === "function" ? [] : source.imports ?? [];
     const useFactory = async (...deps) => new HttpClientOptions(await load(...deps));
     if (name !== undefined) {
-      return namedModule(name, { useFactory, inject });
+      return namedModule(name, { useFactory, inject }, imports);
     }
     return {
       module: HttpModule,
+      imports,
       exports: [HttpClientOptions, HttpService],
       providers: [
         provide(HttpClientOptions, { useFactory, inject }),

package/dist/compression/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type CompressionOptionsInit } from './options.js';
 /**
  * Binds `Compression` and its options. Like `StaticModule`, importing it does not
@@ -14,7 +14,5 @@ import { type CompressionOptionsInit } from './options.js';
 export declare class CompressionModule {
     static forRoot(init?: CompressionOptionsInit): DynamicModule;
     /** `forRoot` with the options read off the container - a config value, usually. */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<CompressionOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
-    }): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<CompressionOptionsInit, D>): DynamicModule;
 }

package/dist/health/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type HealthOptionsInit } from './registry.js';
 /**
  * Liveness and readiness, and the drain that makes readiness worth having.
@@ -33,8 +33,7 @@ export declare class HealthModule {
      * table is folded into one closure per route when the server binds, so it cannot
      * wait on a factory. Pass `routes: false` and mount your own if that matters.
      */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<HealthOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<HealthOptionsInit, D> & {
         readonly routes?: boolean;
         readonly documented?: boolean;
     }): DynamicModule;

package/dist/health/readiness.d.ts

@@ -1,5 +1,5 @@
 import type { OnBeforeShutdown } from '@dunx/core';
-export interface ReadinessOptionsInit {
+interface ReadinessOptionsInit {
     /**
      * How long to keep failing readiness after the drain starts, before the server
      * stops accepting. Default `0`.
@@ -49,3 +49,4 @@ export declare class Readiness implements OnBeforeShutdown {
      */
     onBeforeShutdown(): Promise<void>;
 }
+export {};

package/dist/index.js

@@ -77,6 +77,8 @@ var trustedHops = (setting) => {
     return 0;
   return Number.isFinite(setting) ? Math.max(0, Math.trunc(setting)) : 0;
 };
+var IPV4_MAPPED = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/i;
+var unmap = (address) => address === undefined ? undefined : IPV4_MAPPED.exec(address)?.[1] ?? address;
 var sources = new WeakMap;
 
 class ClientAddress {
@@ -90,9 +92,9 @@ class ClientAddress {
       const entries = (req.headers.get("x-forwarded-for") ?? "").split(",").map((entry2) => entry2.trim()).filter((entry2) => entry2.length > 0);
       const entry = entries[Math.max(0, entries.length - hops)];
       if (entry)
-        return entry;
+        return unmap(entry);
     }
-    return source.server.requestIP(req)?.address;
+    return unmap(source.server.requestIP(req)?.address);
   }
 }
 var attachAddressSource = (target, source) => {

package/dist/server/client-address.d.ts

@@ -1,5 +1,5 @@
 import type { BunRequest, Server } from 'bun';
-export interface AddressSource {
+interface AddressSource {
     readonly server: Server<unknown>;
     readonly trustProxy: boolean | number;
 }
@@ -8,6 +8,9 @@ export interface AddressSource {
  * right of `X-Forwarded-For` by the number of trusted hops, never from the left: a
  * client can send anything, and only the entries a proxy appended carry weight.
  *
+ * An IPv4-mapped IPv6 address is returned in its IPv4 form: `::ffff:10.0.0.1`
+ * comes back as `10.0.0.1`, from the header and from the socket alike.
+ *
  * Bound by `HttpFactory`'s global wrapper, which is not optional under module
  * scoping - an unbound class self-binds into whichever scope asks first, so a
  * second module injecting it was a boot error.
@@ -17,3 +20,4 @@ export declare class ClientAddress {
 }
 /** Internal: `listen()` hands the bound server to the resolved singleton. */
 export declare const attachAddressSource: (target: ClientAddress, source: AddressSource) => void;
+export {};

package/dist/static/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type StaticOptionsInit } from './options.js';
 /**
  * Serves a directory. Like the dashboard, it does not register itself:
@@ -46,7 +46,5 @@ import { type StaticOptionsInit } from './options.js';
 export declare class StaticModule {
     static forRoot(init: StaticOptionsInit): DynamicModule;
     /** `forRoot` with the root read off the container - a config value, usually. */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<StaticOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
-    }): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<StaticOptionsInit, D>): DynamicModule;
 }

package/dist/throttle/module.d.ts

@@ -1,4 +1,4 @@
-import { type Deps, type DynamicModule, type FactoryProvider } from '@dunx/core';
+import { type Deps, type DynamicModule, type AsyncModuleConfig } from '@dunx/core';
 import { type ThrottleOptionsInit } from './options.js';
 /**
  * The decorator, the guard, the counter and its options.
@@ -27,7 +27,5 @@ import { type ThrottleOptionsInit } from './options.js';
 export declare class ThrottleModule {
     static forRoot(init: ThrottleOptionsInit): DynamicModule;
     /** `forRoot` with the limit read off the container - a config value, usually. */
-    static forRootAsync<const D extends Deps>(config: FactoryProvider<ThrottleOptionsInit, D> & {
-        readonly imports?: DynamicModule['imports'];
-    }): DynamicModule;
+    static forRootAsync<const D extends Deps>(config: AsyncModuleConfig<ThrottleOptionsInit, D>): DynamicModule;
 }

package/dist/ws/adapter.d.ts

@@ -31,10 +31,11 @@ export interface WebSocketRuntime {
      */
     readonly warnings: readonly string[];
 }
-export interface GatewaySummary {
+interface GatewaySummary {
     readonly name: string;
     readonly path: string;
     /** `@OnMessage('name')` events. A raw catch-all has no name to report. */
     readonly events: readonly string[];
 }
 export declare const buildWebSocket: (discovered: readonly DiscoveredGateway[], options?: SocketOptions, middleware?: readonly SocketMiddleware[]) => WebSocketRuntime;
+export {};

package/dist/ws/discover.d.ts

@@ -1,4 +1,4 @@
-import { type Ctor, type InjectionToken, type ResolvedModule } from '@dunx/core';
+import { type InjectionToken, type ResolvedModule } from '@dunx/core';
 import { type HandlerKind } from './marker.js';
 /**
  * A discovered handler, already bound to its instance. Every kind has a different
@@ -26,12 +26,6 @@ export declare const normalizePath: (path: string) => string;
  * handler is bound off the instance.
  */
 export declare const discoverGateway: (instance: object) => DiscoveredGateway;
-/**
- * The name of the first handler a class declares, without constructing it. A
- * provider that declares one but is not a gateway would silently never receive a
- * frame, so that becomes a boot error naming the method.
- */
-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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/http",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Bun.serve adapter for the dunx framework: controllers, middleware and WebSocket gateways",
   "keywords": [
     "bun",
@@ -62,7 +62,7 @@
     "@dunx/core": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.0.1",
+    "@dunx/core": "^3.0.2",
     "@types/bun": ">=1.3.0"
   },
   "peerDependenciesMeta": {