@hazeljs/gateway 0.2.0-beta.41

package/dist/decorators/index.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Gateway Decorators
+ * Declarative API for defining gateway routes and policies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Gateway = Gateway;
+exports.Route = Route;
+exports.ServiceRoute = ServiceRoute;
+exports.VersionRoute = VersionRoute;
+exports.Canary = Canary;
+exports.TrafficPolicy = TrafficPolicy;
+exports.GatewayCircuitBreaker = GatewayCircuitBreaker;
+exports.GatewayRateLimit = GatewayRateLimit;
+exports.getGatewayConfig = getGatewayConfig;
+exports.getRouteConfig = getRouteConfig;
+exports.getServiceRouteConfig = getServiceRouteConfig;
+exports.getVersionRouteConfig = getVersionRouteConfig;
+exports.getCanaryConfig = getCanaryConfig;
+exports.getTrafficPolicyConfig = getTrafficPolicyConfig;
+exports.getCircuitBreakerConfig = getCircuitBreakerConfig;
+exports.getRateLimitConfig = getRateLimitConfig;
+exports.collectRouteDefinitions = collectRouteDefinitions;
+require("reflect-metadata");
+// Metadata keys
+const GATEWAY_CONFIG_KEY = Symbol('gateway:config');
+const GATEWAY_PROPERTIES_KEY = Symbol('gateway:properties');
+const ROUTE_KEY = Symbol('gateway:route');
+const SERVICE_ROUTE_KEY = Symbol('gateway:serviceRoute');
+const VERSION_ROUTE_KEY = Symbol('gateway:versionRoute');
+const CANARY_KEY = Symbol('gateway:canary');
+const TRAFFIC_POLICY_KEY = Symbol('gateway:trafficPolicy');
+const CIRCUIT_BREAKER_KEY = Symbol('gateway:circuitBreaker');
+const RATE_LIMIT_KEY = Symbol('gateway:rateLimit');
+/**
+ * Track a property as a gateway-decorated property.
+ * This is needed because TypeScript class property declarations don't appear
+ * on the prototype, so we can't discover them via Object.getOwnPropertyNames.
+ */
+function trackProperty(target, propertyKey) {
+    const existing = Reflect.getMetadata(GATEWAY_PROPERTIES_KEY, target) || new Set();
+    existing.add(String(propertyKey));
+    Reflect.defineMetadata(GATEWAY_PROPERTIES_KEY, existing, target);
+}
+/**
+ * @Gateway class decorator
+ * Marks a class as a gateway definition with global configuration.
+ */
+function Gateway(config) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- ClassDecorator requires Function
+    return function (target) {
+        Reflect.defineMetadata(GATEWAY_CONFIG_KEY, config, target);
+    };
+}
+/**
+ * @Route property/method decorator
+ * Defines a URL pattern this route handles.
+ */
+function Route(pathOrConfig) {
+    return function (target, propertyKey) {
+        const config = typeof pathOrConfig === 'string' ? { path: pathOrConfig } : pathOrConfig;
+        Reflect.defineMetadata(ROUTE_KEY, config, target, propertyKey);
+        trackProperty(target, propertyKey);
+    };
+}
+/**
+ * @ServiceRoute property/method decorator
+ * Maps this route to a service in the discovery registry.
+ */
+function ServiceRoute(nameOrConfig) {
+    return function (target, propertyKey) {
+        const config = typeof nameOrConfig === 'string' ? { serviceName: nameOrConfig } : nameOrConfig;
+        Reflect.defineMetadata(SERVICE_ROUTE_KEY, config, target, propertyKey);
+        trackProperty(target, propertyKey);
+    };
+}
+/**
+ * @VersionRoute property/method decorator
+ * Enables version-based routing for this route.
+ */
+function VersionRoute(config) {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(VERSION_ROUTE_KEY, config, target, propertyKey);
+    };
+}
+/**
+ * @Canary property/method decorator
+ * Enables canary deployment for this route.
+ */
+function Canary(config) {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(CANARY_KEY, config, target, propertyKey);
+    };
+}
+/**
+ * @TrafficPolicy property/method decorator
+ * Defines traffic policies (mirroring, transformation, etc.)
+ */
+function TrafficPolicy(config) {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(TRAFFIC_POLICY_KEY, config, target, propertyKey);
+    };
+}
+/**
+ * @CircuitBreaker property decorator (gateway-specific)
+ * Overrides circuit breaker configuration for this route.
+ */
+function GatewayCircuitBreaker(config) {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(CIRCUIT_BREAKER_KEY, config, target, propertyKey);
+    };
+}
+/**
+ * @RateLimit property decorator (gateway-specific)
+ * Overrides rate limit configuration for this route.
+ */
+function GatewayRateLimit(config) {
+    return function (target, propertyKey) {
+        Reflect.defineMetadata(RATE_LIMIT_KEY, config, target, propertyKey);
+    };
+}
+// ─── Metadata Readers ───
+function getGatewayConfig(target) {
+    return Reflect.getMetadata(GATEWAY_CONFIG_KEY, target);
+}
+function getRouteConfig(target, propertyKey) {
+    return Reflect.getMetadata(ROUTE_KEY, target, propertyKey);
+}
+function getServiceRouteConfig(target, propertyKey) {
+    return Reflect.getMetadata(SERVICE_ROUTE_KEY, target, propertyKey);
+}
+function getVersionRouteConfig(target, propertyKey) {
+    return Reflect.getMetadata(VERSION_ROUTE_KEY, target, propertyKey);
+}
+function getCanaryConfig(target, propertyKey) {
+    return Reflect.getMetadata(CANARY_KEY, target, propertyKey);
+}
+function getTrafficPolicyConfig(target, propertyKey) {
+    return Reflect.getMetadata(TRAFFIC_POLICY_KEY, target, propertyKey);
+}
+function getCircuitBreakerConfig(target, propertyKey) {
+    return Reflect.getMetadata(CIRCUIT_BREAKER_KEY, target, propertyKey);
+}
+function getRateLimitConfig(target, propertyKey) {
+    return Reflect.getMetadata(RATE_LIMIT_KEY, target, propertyKey);
+}
+/**
+ * Collect all route definitions from a gateway class instance
+ */
+function collectRouteDefinitions(gatewayClass) {
+    const config = getGatewayConfig(gatewayClass) || {};
+    const prototype = gatewayClass.prototype;
+    // Get tracked gateway properties (from decorators) + prototype methods
+    const trackedProps = Reflect.getMetadata(GATEWAY_PROPERTIES_KEY, prototype) || new Set();
+    const protoMethods = Object.getOwnPropertyNames(prototype).filter((p) => p !== 'constructor');
+    const allProperties = new Set([...trackedProps, ...protoMethods]);
+    const routes = Array.from(allProperties)
+        .map((propertyKey) => ({
+        propertyKey,
+        route: getRouteConfig(prototype, propertyKey),
+        serviceRoute: getServiceRouteConfig(prototype, propertyKey),
+        versionRoute: getVersionRouteConfig(prototype, propertyKey),
+        canary: getCanaryConfig(prototype, propertyKey),
+        trafficPolicy: getTrafficPolicyConfig(prototype, propertyKey),
+        circuitBreaker: getCircuitBreakerConfig(prototype, propertyKey),
+        rateLimit: getRateLimitConfig(prototype, propertyKey),
+    }))
+        .filter((r) => r.route || r.serviceRoute);
+    return { config, routes };
+}

package/dist/gateway.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Gateway
+ * The main orchestrator that ties together routing, versioning, canary,
+ * resilience, and traffic policies into a unified request handling pipeline.
+ *
+ * Can be used declaratively via decorators or programmatically via config.
+ */
+import { EventEmitter } from 'events';
+import { DiscoveryClient, RegistryBackend } from '@hazeljs/discovery';
+import { GatewayConfig, GatewayFullConfig, GatewayRouteDefinition, ProxyRequest, ProxyResponse } from './types';
+import { CanaryEngine } from './canary/canary-engine';
+import { GatewayMetrics } from './metrics/gateway-metrics';
+export declare class GatewayServer extends EventEmitter {
+    private discoveryClient;
+    private routes;
+    private sortedPatterns;
+    private metrics;
+    private config;
+    constructor(config: GatewayConfig, backend?: RegistryBackend);
+    /**
+     * Create a gateway from a plain configuration object.
+     * This is the production-recommended approach — config values come from
+     * env vars / config files via @hazeljs/config instead of hardcoded decorators.
+     */
+    static fromConfig(config: GatewayFullConfig, backend?: RegistryBackend): GatewayServer;
+    /**
+     * Create a gateway from a decorated class
+     */
+    static fromClass(gatewayClass: new (...args: unknown[]) => unknown, backend?: RegistryBackend): GatewayServer;
+    /**
+     * Add a route definition to the gateway
+     */
+    addRoute(definition: GatewayRouteDefinition): void;
+    /**
+     * Handle an incoming request through the gateway pipeline
+     */
+    handleRequest(request: ProxyRequest): Promise<ProxyResponse>;
+    /**
+     * Start all canary engines
+     */
+    startCanaries(): void;
+    /**
+     * Stop all canary engines and clean up
+     */
+    stop(): void;
+    /**
+     * Get the gateway metrics
+     */
+    getMetrics(): GatewayMetrics;
+    /**
+     * Get the canary engine for a specific route
+     */
+    getCanaryEngine(routePath: string): CanaryEngine | undefined;
+    /**
+     * Get all route paths
+     */
+    getRoutes(): string[];
+    /**
+     * Get the discovery client
+     */
+    getDiscoveryClient(): DiscoveryClient;
+    private findHandler;
+    private handleCanaryRequest;
+    private handleVersionedRequest;
+    private createCanaryEngine;
+}
+//# sourceMappingURL=gateway.d.ts.map

package/dist/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../src/gateway.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,sBAAsB,EACtB,YAAY,EACZ,aAAa,EAGd,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAa3D,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe;IAQ5D;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,aAAa;IAQtF;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,YAAY,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EACjD,OAAO,CAAC,EAAE,eAAe,GACxB,aAAa;IAuBhB;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,sBAAsB,GAAG,IAAI;IA8ClD;;OAEG;IACG,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA6FlE;;OAEG;IACH,aAAa,IAAI,IAAI;IAQrB;;OAEG;IACH,IAAI,IAAI,IAAI;IASZ;;OAEG;IACH,UAAU,IAAI,cAAc;IAI5B;;OAEG;IACH,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAI5D;;OAEG;IACH,SAAS,IAAI,MAAM,EAAE;IAIrB;;OAEG;IACH,kBAAkB,IAAI,eAAe;IAMrC,OAAO,CAAC,WAAW;YAUL,mBAAmB;YAoCnB,sBAAsB;IAgCpC,OAAO,CAAC,kBAAkB;CA2B3B"}

package/dist/gateway.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Gateway
+ * The main orchestrator that ties together routing, versioning, canary,
+ * resilience, and traffic policies into a unified request handling pipeline.
+ *
+ * Can be used declaratively via decorators or programmatically via config.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayServer = void 0;
+const events_1 = require("events");
+const discovery_1 = require("@hazeljs/discovery");
+const resilience_1 = require("@hazeljs/resilience");
+const service_proxy_1 = require("./proxy/service-proxy");
+const version_router_1 = require("./routing/version-router");
+const canary_engine_1 = require("./canary/canary-engine");
+const gateway_metrics_1 = require("./metrics/gateway-metrics");
+const traffic_mirror_1 = require("./middleware/traffic-mirror");
+const route_matcher_1 = require("./routing/route-matcher");
+const decorators_1 = require("./decorators");
+class GatewayServer extends events_1.EventEmitter {
+    constructor(config, backend) {
+        super();
+        this.routes = new Map();
+        this.sortedPatterns = [];
+        this.config = config;
+        this.metrics = new gateway_metrics_1.GatewayMetrics(config.metrics?.windowSize ?? 60000);
+        this.discoveryClient = new discovery_1.DiscoveryClient(config.discovery ?? {}, backend);
+    }
+    /**
+     * Create a gateway from a plain configuration object.
+     * This is the production-recommended approach — config values come from
+     * env vars / config files via @hazeljs/config instead of hardcoded decorators.
+     */
+    static fromConfig(config, backend) {
+        const gateway = new GatewayServer(config, backend);
+        for (const route of config.routes) {
+            gateway.addRoute(route);
+        }
+        return gateway;
+    }
+    /**
+     * Create a gateway from a decorated class
+     */
+    static fromClass(gatewayClass, backend) {
+        const { config, routes } = (0, decorators_1.collectRouteDefinitions)(gatewayClass);
+        const gateway = new GatewayServer(config, backend);
+        for (const routeDef of routes) {
+            if (!routeDef.route || !routeDef.serviceRoute)
+                continue;
+            gateway.addRoute({
+                path: routeDef.route.path,
+                serviceName: routeDef.serviceRoute.serviceName,
+                serviceConfig: routeDef.serviceRoute,
+                versionRoute: routeDef.versionRoute,
+                canary: routeDef.canary,
+                trafficPolicy: routeDef.trafficPolicy,
+                circuitBreaker: routeDef.circuitBreaker,
+                rateLimit: routeDef.rateLimit,
+                methods: routeDef.route.methods,
+            });
+        }
+        return gateway;
+    }
+    /**
+     * Add a route definition to the gateway
+     */
+    addRoute(definition) {
+        const proxyConfig = {
+            serviceName: definition.serviceName,
+            loadBalancingStrategy: definition.serviceConfig?.loadBalancingStrategy,
+            filter: definition.serviceConfig?.filter,
+            stripPrefix: definition.serviceConfig?.stripPrefix,
+            addPrefix: definition.serviceConfig?.addPrefix,
+            timeout: definition.trafficPolicy?.timeout ?? this.config.resilience?.defaultTimeout,
+            retry: definition.trafficPolicy?.retry ?? this.config.resilience?.defaultRetry,
+            circuitBreaker: definition.circuitBreaker ??
+                definition.trafficPolicy?.circuitBreaker ??
+                this.config.resilience?.defaultCircuitBreaker,
+            rateLimit: definition.rateLimit ?? definition.trafficPolicy?.rateLimit,
+            transform: definition.trafficPolicy?.transform,
+        };
+        const proxy = new service_proxy_1.ServiceProxy(this.discoveryClient, proxyConfig);
+        const handler = {
+            definition,
+            proxy,
+        };
+        // Set up version routing
+        if (definition.versionRoute) {
+            handler.versionRouter = new version_router_1.VersionRouter(definition.versionRoute);
+        }
+        // Set up canary deployment
+        if (definition.canary) {
+            handler.canaryEngine = this.createCanaryEngine(definition.canary, definition.path);
+        }
+        // Set up traffic mirroring
+        if (definition.trafficPolicy?.mirror) {
+            handler.trafficMirror = new traffic_mirror_1.TrafficMirror(definition.trafficPolicy.mirror, this.discoveryClient);
+        }
+        this.routes.set(definition.path, handler);
+        this.sortedPatterns = (0, route_matcher_1.sortRoutesBySpecificity)(Array.from(this.routes.keys()));
+    }
+    /**
+     * Handle an incoming request through the gateway pipeline
+     */
+    async handleRequest(request) {
+        const startTime = Date.now();
+        // 1. Match the route
+        const handler = this.findHandler(request);
+        if (!handler) {
+            return {
+                status: 404,
+                headers: {},
+                body: { error: 'No matching gateway route', path: request.path },
+            };
+        }
+        // Check method
+        if (handler.definition.methods &&
+            handler.definition.methods.length > 0 &&
+            !handler.definition.methods.includes(request.method.toUpperCase())) {
+            return {
+                status: 405,
+                headers: {},
+                body: { error: 'Method not allowed' },
+            };
+        }
+        try {
+            let response;
+            // 2. Canary routing takes priority
+            if (handler.canaryEngine) {
+                response = await this.handleCanaryRequest(handler, request);
+            }
+            // 3. Version routing
+            else if (handler.versionRouter) {
+                response = await this.handleVersionedRequest(handler, request);
+            }
+            // 4. Direct proxy
+            else {
+                response = await handler.proxy.forward(request);
+            }
+            // 5. Mirror traffic (fire and forget)
+            if (handler.trafficMirror) {
+                handler.trafficMirror.mirror(request);
+            }
+            // 6. Record metrics
+            const duration = Date.now() - startTime;
+            const isError = response.status >= 500;
+            if (isError) {
+                this.metrics.recordFailure(handler.definition.path, duration, `HTTP ${response.status}`);
+            }
+            else {
+                this.metrics.recordSuccess(handler.definition.path, duration);
+            }
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.metrics.recordFailure(handler.definition.path, duration, String(error));
+            this.emit('route:error', {
+                route: handler.definition.path,
+                service: handler.definition.serviceName,
+                error: String(error),
+            });
+            // Return 429 for rate limit exceeded (RFC 6585)
+            if (error instanceof resilience_1.RateLimitError) {
+                const retryAfterSec = error.retryAfterMs ? Math.ceil(error.retryAfterMs / 1000) : 60;
+                return {
+                    status: 429,
+                    headers: { 'Retry-After': String(retryAfterSec) },
+                    body: {
+                        error: 'Too Many Requests',
+                        message: error.message,
+                        retryAfter: retryAfterSec,
+                    },
+                };
+            }
+            return {
+                status: 502,
+                headers: {},
+                body: {
+                    error: 'Bad Gateway',
+                    message: error instanceof Error ? error.message : String(error),
+                    service: handler.definition.serviceName,
+                },
+            };
+        }
+    }
+    /**
+     * Start all canary engines
+     */
+    startCanaries() {
+        for (const handler of this.routes.values()) {
+            if (handler.canaryEngine) {
+                handler.canaryEngine.start();
+            }
+        }
+    }
+    /**
+     * Stop all canary engines and clean up
+     */
+    stop() {
+        for (const handler of this.routes.values()) {
+            if (handler.canaryEngine) {
+                handler.canaryEngine.stop();
+            }
+        }
+        this.discoveryClient.close();
+    }
+    /**
+     * Get the gateway metrics
+     */
+    getMetrics() {
+        return this.metrics;
+    }
+    /**
+     * Get the canary engine for a specific route
+     */
+    getCanaryEngine(routePath) {
+        return this.routes.get(routePath)?.canaryEngine;
+    }
+    /**
+     * Get all route paths
+     */
+    getRoutes() {
+        return Array.from(this.routes.keys());
+    }
+    /**
+     * Get the discovery client
+     */
+    getDiscoveryClient() {
+        return this.discoveryClient;
+    }
+    // ─── Internal ───
+    findHandler(request) {
+        for (const pattern of this.sortedPatterns) {
+            const match = (0, route_matcher_1.matchRoute)(pattern, request.path);
+            if (match.matched) {
+                return this.routes.get(pattern);
+            }
+        }
+        return undefined;
+    }
+    async handleCanaryRequest(handler, request) {
+        const engine = handler.canaryEngine;
+        const target = engine.selectVersion(request);
+        const version = engine.getVersion(target);
+        const startTime = Date.now();
+        try {
+            const response = await handler.proxy.forwardToVersion(request, version);
+            const duration = Date.now() - startTime;
+            const isError = response.status >= 500;
+            if (isError) {
+                engine.recordFailure(target, duration, `HTTP ${response.status}`);
+                this.metrics.recordFailure(handler.definition.path, duration, `HTTP ${response.status}`, version);
+            }
+            else {
+                engine.recordSuccess(target, duration);
+                this.metrics.recordSuccess(handler.definition.path, duration, version);
+            }
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            engine.recordFailure(target, duration, String(error));
+            this.metrics.recordFailure(handler.definition.path, duration, String(error), version);
+            throw error;
+        }
+    }
+    async handleVersionedRequest(handler, request) {
+        const router = handler.versionRouter;
+        const resolution = router.resolve(request);
+        const startTime = Date.now();
+        try {
+            const entry = router.getVersionEntry(resolution.version);
+            const response = await handler.proxy.forwardToVersion(request, resolution.version, entry?.filter);
+            const duration = Date.now() - startTime;
+            this.metrics.recordSuccess(handler.definition.path, duration, resolution.version);
+            return response;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.metrics.recordFailure(handler.definition.path, duration, String(error), resolution.version);
+            throw error;
+        }
+    }
+    createCanaryEngine(config, routePath) {
+        const engine = new canary_engine_1.CanaryEngine(config);
+        // Forward canary events to the gateway
+        engine.on('canary:promote', (data) => {
+            this.emit('canary:promote', {
+                route: routePath,
+                ...data,
+            });
+        });
+        engine.on('canary:rollback', (data) => {
+            this.emit('canary:rollback', {
+                route: routePath,
+                ...data,
+            });
+        });
+        engine.on('canary:complete', (data) => {
+            this.emit('canary:complete', {
+                route: routePath,
+                ...data,
+            });
+        });
+        return engine;
+    }
+}
+exports.GatewayServer = GatewayServer;

package/dist/gateway.module.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Gateway Module
+ * Integrates @hazeljs/gateway with @hazeljs/config for config-driven routing.
+ *
+ * Usage:
+ *   1. Define a gateway config loader (gateway.config.ts) that reads env vars
+ *   2. Register it with ConfigModule.forRoot({ load: [gatewayConfig] })
+ *   3. Use GatewayModule.forRoot() to create the gateway from config
+ *
+ * Example:
+ *   GatewayModule.forRoot({ configKey: 'gateway' })
+ *   // reads ConfigService.get('gateway') -> GatewayFullConfig
+ */
+import { GatewayFullConfig } from './types';
+export interface GatewayModuleOptions {
+    /**
+     * Key in ConfigService to read gateway config from.
+     * The value at this key should conform to GatewayFullConfig.
+     * Default: 'gateway'
+     */
+    configKey?: string;
+    /**
+     * Provide gateway config directly (for programmatic use
+     * without @hazeljs/config dependency).
+     * If both `config` and `configKey` are set, `config` takes precedence.
+     */
+    config?: GatewayFullConfig;
+}
+/**
+ * GatewayModule follows the same forRoot() pattern as ConfigModule.
+ *
+ * It stores the options statically so the gateway can be created later
+ * when the app boots and ConfigService is available.
+ */
+export declare class GatewayModule {
+    private static options;
+    /**
+     * Register the gateway module with configuration options.
+     *
+     * @example
+     * // Config-driven (reads from ConfigService):
+     * GatewayModule.forRoot({ configKey: 'gateway' })
+     *
+     * // Direct config (no ConfigService needed):
+     * GatewayModule.forRoot({ config: { discovery: {...}, routes: [...] } })
+     */
+    static forRoot(options?: GatewayModuleOptions): {
+        module: typeof GatewayModule;
+    };
+    /**
+     * Get the registered options.
+     */
+    static getOptions(): GatewayModuleOptions;
+    /**
+     * Resolve the gateway configuration.
+     *
+     * If `config` was provided directly, returns it.
+     * Otherwise, reads from the provided ConfigService using the configKey.
+     *
+     * @param configService - Optional ConfigService instance. Required if
+     *   no direct `config` was provided in forRoot().
+     */
+    static resolveConfig(configService?: {
+        get: <T>(key: string) => T | undefined;
+    }): GatewayFullConfig;
+}
+//# sourceMappingURL=gateway.module.d.ts.map

package/dist/gateway.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.module.d.ts","sourceRoot":"","sources":["../src/gateway.module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,OAAO,CAA4B;IAElD;;;;;;;;;OASG;IACH,MAAM,CAAC,OAAO,CAAC,OAAO,GAAE,oBAAyB,GAAG;QAAE,MAAM,EAAE,OAAO,aAAa,CAAA;KAAE;IAQpF;;OAEG;IACH,MAAM,CAAC,UAAU,IAAI,oBAAoB;IAIzC;;;;;;;;OAQG;IACH,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,EAAE;QACnC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC;KACxC,GAAG,iBAAiB;CAoCtB"}