@hazeljs/gateway 0.2.0-beta.41

package/dist/gateway.module.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayModule = void 0;
+/**
+ * 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.
+ */
+class GatewayModule {
+    /**
+     * 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 = {}) {
+        GatewayModule.options = {
+            configKey: 'gateway',
+            ...options,
+        };
+        return { module: GatewayModule };
+    }
+    /**
+     * Get the registered options.
+     */
+    static getOptions() {
+        return GatewayModule.options;
+    }
+    /**
+     * 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) {
+        const opts = GatewayModule.options;
+        // Direct config takes precedence
+        if (opts.config) {
+            return opts.config;
+        }
+        // Otherwise read from ConfigService
+        if (!configService) {
+            throw new Error('GatewayModule: No config provided and no ConfigService available. ' +
+                'Either pass config directly via GatewayModule.forRoot({ config: {...} }) ' +
+                'or provide a ConfigService instance.');
+        }
+        const key = opts.configKey || 'gateway';
+        const config = configService.get(key);
+        if (!config) {
+            throw new Error(`GatewayModule: No configuration found at key "${key}". ` +
+                `Make sure your config loader returns a "${key}" key with routes.`);
+        }
+        if (!config.routes || !Array.isArray(config.routes)) {
+            throw new Error(`GatewayModule: Configuration at key "${key}" is missing a "routes" array. ` +
+                'Each route needs at least { path, serviceName }.');
+        }
+        return config;
+    }
+}
+exports.GatewayModule = GatewayModule;
+GatewayModule.options = {};

package/dist/hazel-integration.d.ts

@@ -0,0 +1,24 @@
+/**
+ * HazelJS Core Integration
+ * Creates a proxy handler for use with HazelApp.addProxyHandler()
+ *
+ * @example
+ * ```typescript
+ * import { HazelApp } from '@hazeljs/core';
+ * import { GatewayServer, createGatewayHandler } from '@hazeljs/gateway';
+ *
+ * const gateway = GatewayServer.fromConfig(config);
+ * const app = new HazelApp(AppModule);
+ * app.addProxyHandler('/api', createGatewayHandler(gateway));
+ * app.listen(3000);
+ * ```
+ */
+import { IncomingMessage, ServerResponse } from 'http';
+import type { RequestContext } from '@hazeljs/core';
+import type { GatewayServer } from './gateway';
+/**
+ * Create a proxy handler that bridges Node.js HTTP to GatewayServer.handleRequest().
+ * Use with HazelApp.addProxyHandler(pathPrefix, createGatewayHandler(gateway)).
+ */
+export declare function createGatewayHandler(gateway: GatewayServer): (req: IncomingMessage, res: ServerResponse, context: RequestContext) => Promise<boolean>;
+//# sourceMappingURL=hazel-integration.d.ts.map

package/dist/hazel-integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hazel-integration.d.ts","sourceRoot":"","sources":["../src/hazel-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG/C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,IAEvD,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,SAAS,cAAc,KACtB,OAAO,CAAC,OAAO,CAAC,CAMpB"}

package/dist/hazel-integration.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * HazelJS Core Integration
+ * Creates a proxy handler for use with HazelApp.addProxyHandler()
+ *
+ * @example
+ * ```typescript
+ * import { HazelApp } from '@hazeljs/core';
+ * import { GatewayServer, createGatewayHandler } from '@hazeljs/gateway';
+ *
+ * const gateway = GatewayServer.fromConfig(config);
+ * const app = new HazelApp(AppModule);
+ * app.addProxyHandler('/api', createGatewayHandler(gateway));
+ * app.listen(3000);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGatewayHandler = createGatewayHandler;
+/**
+ * Create a proxy handler that bridges Node.js HTTP to GatewayServer.handleRequest().
+ * Use with HazelApp.addProxyHandler(pathPrefix, createGatewayHandler(gateway)).
+ */
+function createGatewayHandler(gateway) {
+    return async function gatewayHandler(req, res, context) {
+        const proxyRequest = toProxyRequest(req, context);
+        const proxyResponse = await gateway.handleRequest(proxyRequest);
+        writeProxyResponse(res, proxyResponse);
+        return true;
+    };
+}
+function toProxyRequest(req, context) {
+    const url = req.url || '/';
+    const pathname = url.split('?')[0];
+    const headers = {};
+    if (req.headers) {
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (value !== undefined) {
+                headers[key] = Array.isArray(value) ? value.join(', ') : String(value);
+            }
+        }
+    }
+    return {
+        method: context.method || req.method || 'GET',
+        path: pathname,
+        headers,
+        body: context.body,
+        query: context.query ?? {},
+    };
+}
+function writeProxyResponse(res, proxyRes) {
+    if (res.writableEnded)
+        return;
+    const headers = {};
+    for (const [key, value] of Object.entries(proxyRes.headers)) {
+        if (value !== undefined) {
+            headers[key] = Array.isArray(value) ? value.join(', ') : String(value);
+        }
+    }
+    if (!headers['content-type']) {
+        headers['content-type'] = 'application/json';
+    }
+    res.writeHead(proxyRes.status, headers);
+    if (proxyRes.body !== undefined) {
+        const body = typeof proxyRes.body === 'string' ? proxyRes.body : JSON.stringify(proxyRes.body);
+        res.end(body);
+    }
+    else {
+        res.end();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @hazeljs/gateway
+ * Intelligent API Gateway for HazelJS
+ *
+ * Provides version-based routing, canary deployments, circuit breaking,
+ * traffic management, and automatic rollback — all via decorators or
+ * programmatic API.
+ */
+export { GatewayConfig, GatewayFullConfig, GatewayResilienceDefaults, GatewayMetricsConfig, GatewayMiddlewareConfig, CorsConfig, RouteConfig, ServiceRouteConfig, VersionResolutionStrategy, VersionRouteConfig, VersionRouteEntry, CanaryConfig, CanaryVersionConfig, CanaryPromotionConfig, CanaryMetrics, CanaryVersionMetrics, CanaryDecision, CanaryState, TrafficPolicyConfig, TrafficMirrorConfig, TrafficTransformConfig, ProxyRequest, ProxyResponse, GatewayRouteDefinition, GatewayEvent, GatewayEventType, } from './types';
+export { GatewayServer } from './gateway';
+export { GatewayModule, GatewayModuleOptions } from './gateway.module';
+export { ServiceProxy, ServiceProxyConfig } from './proxy/service-proxy';
+export { VersionRouter, VersionResolution } from './routing/version-router';
+export { matchRoute, sortRoutesBySpecificity, RouteMatch } from './routing/route-matcher';
+export { CanaryEngine, CanaryStatus, parseInterval } from './canary/canary-engine';
+export { GatewayMetrics, GatewayMetricsSnapshot, RouteMetricsSnapshot, } from './metrics/gateway-metrics';
+export { TrafficMirror } from './middleware/traffic-mirror';
+export { createGatewayHandler } from './hazel-integration';
+export { Gateway, Route, ServiceRoute, VersionRoute, Canary, TrafficPolicy, GatewayCircuitBreaker, GatewayRateLimit, getGatewayConfig, getRouteConfig, getServiceRouteConfig, getVersionRouteConfig, getCanaryConfig, getTrafficPolicyConfig, getCircuitBreakerConfig, getRateLimitConfig, collectRouteDefinitions, } from './decorators';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,yBAAyB,EACzB,oBAAoB,EACpB,uBAAuB,EACvB,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,yBAAyB,EACzB,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,WAAW,EACX,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACtB,YAAY,EACZ,aAAa,EACb,sBAAsB,EACtB,YAAY,EACZ,gBAAgB,GACjB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGvE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGzE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1F,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGnF,OAAO,EACL,cAAc,EACd,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAG5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAG3D,OAAO,EACL,OAAO,EACP,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAEhB,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @hazeljs/gateway
+ * Intelligent API Gateway for HazelJS
+ *
+ * Provides version-based routing, canary deployments, circuit breaking,
+ * traffic management, and automatic rollback — all via decorators or
+ * programmatic API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRouteDefinitions = exports.getRateLimitConfig = exports.getCircuitBreakerConfig = exports.getTrafficPolicyConfig = exports.getCanaryConfig = exports.getVersionRouteConfig = exports.getServiceRouteConfig = exports.getRouteConfig = exports.getGatewayConfig = exports.GatewayRateLimit = exports.GatewayCircuitBreaker = exports.TrafficPolicy = exports.Canary = exports.VersionRoute = exports.ServiceRoute = exports.Route = exports.Gateway = exports.createGatewayHandler = exports.TrafficMirror = exports.GatewayMetrics = exports.parseInterval = exports.CanaryEngine = exports.sortRoutesBySpecificity = exports.matchRoute = exports.VersionRouter = exports.ServiceProxy = exports.GatewayModule = exports.GatewayServer = exports.CanaryState = void 0;
+// Types
+var types_1 = require("./types");
+Object.defineProperty(exports, "CanaryState", { enumerable: true, get: function () { return types_1.CanaryState; } });
+// Gateway Server
+var gateway_1 = require("./gateway");
+Object.defineProperty(exports, "GatewayServer", { enumerable: true, get: function () { return gateway_1.GatewayServer; } });
+// Gateway Module (config integration)
+var gateway_module_1 = require("./gateway.module");
+Object.defineProperty(exports, "GatewayModule", { enumerable: true, get: function () { return gateway_module_1.GatewayModule; } });
+// Service Proxy
+var service_proxy_1 = require("./proxy/service-proxy");
+Object.defineProperty(exports, "ServiceProxy", { enumerable: true, get: function () { return service_proxy_1.ServiceProxy; } });
+// Routing
+var version_router_1 = require("./routing/version-router");
+Object.defineProperty(exports, "VersionRouter", { enumerable: true, get: function () { return version_router_1.VersionRouter; } });
+var route_matcher_1 = require("./routing/route-matcher");
+Object.defineProperty(exports, "matchRoute", { enumerable: true, get: function () { return route_matcher_1.matchRoute; } });
+Object.defineProperty(exports, "sortRoutesBySpecificity", { enumerable: true, get: function () { return route_matcher_1.sortRoutesBySpecificity; } });
+// Canary Engine
+var canary_engine_1 = require("./canary/canary-engine");
+Object.defineProperty(exports, "CanaryEngine", { enumerable: true, get: function () { return canary_engine_1.CanaryEngine; } });
+Object.defineProperty(exports, "parseInterval", { enumerable: true, get: function () { return canary_engine_1.parseInterval; } });
+// Metrics
+var gateway_metrics_1 = require("./metrics/gateway-metrics");
+Object.defineProperty(exports, "GatewayMetrics", { enumerable: true, get: function () { return gateway_metrics_1.GatewayMetrics; } });
+// Traffic Mirror
+var traffic_mirror_1 = require("./middleware/traffic-mirror");
+Object.defineProperty(exports, "TrafficMirror", { enumerable: true, get: function () { return traffic_mirror_1.TrafficMirror; } });
+// HazelJS Core Integration
+var hazel_integration_1 = require("./hazel-integration");
+Object.defineProperty(exports, "createGatewayHandler", { enumerable: true, get: function () { return hazel_integration_1.createGatewayHandler; } });
+// Decorators
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "Gateway", { enumerable: true, get: function () { return decorators_1.Gateway; } });
+Object.defineProperty(exports, "Route", { enumerable: true, get: function () { return decorators_1.Route; } });
+Object.defineProperty(exports, "ServiceRoute", { enumerable: true, get: function () { return decorators_1.ServiceRoute; } });
+Object.defineProperty(exports, "VersionRoute", { enumerable: true, get: function () { return decorators_1.VersionRoute; } });
+Object.defineProperty(exports, "Canary", { enumerable: true, get: function () { return decorators_1.Canary; } });
+Object.defineProperty(exports, "TrafficPolicy", { enumerable: true, get: function () { return decorators_1.TrafficPolicy; } });
+Object.defineProperty(exports, "GatewayCircuitBreaker", { enumerable: true, get: function () { return decorators_1.GatewayCircuitBreaker; } });
+Object.defineProperty(exports, "GatewayRateLimit", { enumerable: true, get: function () { return decorators_1.GatewayRateLimit; } });
+// Metadata readers
+Object.defineProperty(exports, "getGatewayConfig", { enumerable: true, get: function () { return decorators_1.getGatewayConfig; } });
+Object.defineProperty(exports, "getRouteConfig", { enumerable: true, get: function () { return decorators_1.getRouteConfig; } });
+Object.defineProperty(exports, "getServiceRouteConfig", { enumerable: true, get: function () { return decorators_1.getServiceRouteConfig; } });
+Object.defineProperty(exports, "getVersionRouteConfig", { enumerable: true, get: function () { return decorators_1.getVersionRouteConfig; } });
+Object.defineProperty(exports, "getCanaryConfig", { enumerable: true, get: function () { return decorators_1.getCanaryConfig; } });
+Object.defineProperty(exports, "getTrafficPolicyConfig", { enumerable: true, get: function () { return decorators_1.getTrafficPolicyConfig; } });
+Object.defineProperty(exports, "getCircuitBreakerConfig", { enumerable: true, get: function () { return decorators_1.getCircuitBreakerConfig; } });
+Object.defineProperty(exports, "getRateLimitConfig", { enumerable: true, get: function () { return decorators_1.getRateLimitConfig; } });
+Object.defineProperty(exports, "collectRouteDefinitions", { enumerable: true, get: function () { return decorators_1.collectRouteDefinitions; } });

package/dist/metrics/gateway-metrics.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Gateway Metrics
+ * Aggregates metrics across all routes and services for observability.
+ * Wraps @hazeljs/resilience MetricsCollector per route/service/version.
+ */
+import { MetricsCollector, MetricsSnapshot } from '@hazeljs/resilience';
+export interface RouteMetricsSnapshot {
+    route: string;
+    serviceName: string;
+    version?: string;
+    metrics: MetricsSnapshot;
+}
+export interface GatewayMetricsSnapshot {
+    timestamp: number;
+    totalRoutes: number;
+    routes: RouteMetricsSnapshot[];
+    aggregated: MetricsSnapshot;
+}
+export declare class GatewayMetrics {
+    /** route -> MetricsCollector */
+    private routeMetrics;
+    /** route:version -> MetricsCollector */
+    private versionMetrics;
+    private windowMs;
+    constructor(windowMs?: number);
+    /**
+     * Get or create a metrics collector for a route
+     */
+    getRouteCollector(route: string): MetricsCollector;
+    /**
+     * Get or create a metrics collector for a route+version
+     */
+    getVersionCollector(route: string, version: string): MetricsCollector;
+    /**
+     * Record a successful request
+     */
+    recordSuccess(route: string, duration: number, version?: string): void;
+    /**
+     * Record a failed request
+     */
+    recordFailure(route: string, duration: number, error?: string, version?: string): void;
+    /**
+     * Get metrics for a specific route
+     */
+    getRouteMetrics(route: string): MetricsSnapshot | undefined;
+    /**
+     * Get metrics for a specific route+version
+     */
+    getVersionMetrics(route: string, version: string): MetricsSnapshot | undefined;
+    /**
+     * Get error rate for a specific route+version
+     */
+    getVersionErrorRate(route: string, version: string): number;
+    /**
+     * Get a full snapshot of all gateway metrics
+     */
+    getSnapshot(): GatewayMetricsSnapshot;
+    /**
+     * Reset all metrics
+     */
+    reset(): void;
+    private aggregateMetrics;
+}
+//# sourceMappingURL=gateway-metrics.d.ts.map

package/dist/metrics/gateway-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-metrics.d.ts","sourceRoot":"","sources":["../../src/metrics/gateway-metrics.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAExE,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,eAAe,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,oBAAoB,EAAE,CAAC;IAC/B,UAAU,EAAE,eAAe,CAAC;CAC7B;AAED,qBAAa,cAAc;IACzB,gCAAgC;IAChC,OAAO,CAAC,YAAY,CAAuC;IAC3D,wCAAwC;IACxC,OAAO,CAAC,cAAc,CAAuC;IAC7D,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,GAAE,MAAe;IAIrC;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB;IASlD;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB;IAUrE;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAOtE;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAOtF;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI3D;;OAEG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9E;;OAEG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAK3D;;OAEG;IACH,WAAW,IAAI,sBAAsB;IAsBrC;;OAEG;IACH,KAAK,IAAI,IAAI;IASb,OAAO,CAAC,gBAAgB;CAmDzB"}

package/dist/metrics/gateway-metrics.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Gateway Metrics
+ * Aggregates metrics across all routes and services for observability.
+ * Wraps @hazeljs/resilience MetricsCollector per route/service/version.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayMetrics = void 0;
+const resilience_1 = require("@hazeljs/resilience");
+class GatewayMetrics {
+    constructor(windowMs = 60000) {
+        /** route -> MetricsCollector */
+        this.routeMetrics = new Map();
+        /** route:version -> MetricsCollector */
+        this.versionMetrics = new Map();
+        this.windowMs = windowMs;
+    }
+    /**
+     * Get or create a metrics collector for a route
+     */
+    getRouteCollector(route) {
+        let collector = this.routeMetrics.get(route);
+        if (!collector) {
+            collector = new resilience_1.MetricsCollector(this.windowMs);
+            this.routeMetrics.set(route, collector);
+        }
+        return collector;
+    }
+    /**
+     * Get or create a metrics collector for a route+version
+     */
+    getVersionCollector(route, version) {
+        const key = `${route}:${version}`;
+        let collector = this.versionMetrics.get(key);
+        if (!collector) {
+            collector = new resilience_1.MetricsCollector(this.windowMs);
+            this.versionMetrics.set(key, collector);
+        }
+        return collector;
+    }
+    /**
+     * Record a successful request
+     */
+    recordSuccess(route, duration, version) {
+        this.getRouteCollector(route).recordSuccess(duration);
+        if (version) {
+            this.getVersionCollector(route, version).recordSuccess(duration);
+        }
+    }
+    /**
+     * Record a failed request
+     */
+    recordFailure(route, duration, error, version) {
+        this.getRouteCollector(route).recordFailure(duration, error);
+        if (version) {
+            this.getVersionCollector(route, version).recordFailure(duration, error);
+        }
+    }
+    /**
+     * Get metrics for a specific route
+     */
+    getRouteMetrics(route) {
+        return this.routeMetrics.get(route)?.getSnapshot();
+    }
+    /**
+     * Get metrics for a specific route+version
+     */
+    getVersionMetrics(route, version) {
+        return this.versionMetrics.get(`${route}:${version}`)?.getSnapshot();
+    }
+    /**
+     * Get error rate for a specific route+version
+     */
+    getVersionErrorRate(route, version) {
+        const collector = this.versionMetrics.get(`${route}:${version}`);
+        return collector ? collector.getFailureRate() : 0;
+    }
+    /**
+     * Get a full snapshot of all gateway metrics
+     */
+    getSnapshot() {
+        const routes = [];
+        for (const [route, collector] of this.routeMetrics) {
+            routes.push({
+                route,
+                serviceName: route, // Will be enriched by gateway
+                metrics: collector.getSnapshot(),
+            });
+        }
+        // Aggregate all route metrics
+        const aggregated = this.aggregateMetrics(routes.map((r) => r.metrics));
+        return {
+            timestamp: Date.now(),
+            totalRoutes: routes.length,
+            routes,
+            aggregated,
+        };
+    }
+    /**
+     * Reset all metrics
+     */
+    reset() {
+        for (const collector of this.routeMetrics.values()) {
+            collector.reset();
+        }
+        for (const collector of this.versionMetrics.values()) {
+            collector.reset();
+        }
+    }
+    aggregateMetrics(snapshots) {
+        if (snapshots.length === 0) {
+            return {
+                totalCalls: 0,
+                successCalls: 0,
+                failureCalls: 0,
+                failureRate: 0,
+                averageResponseTime: 0,
+                p50ResponseTime: 0,
+                p95ResponseTime: 0,
+                p99ResponseTime: 0,
+                minResponseTime: 0,
+                maxResponseTime: 0,
+            };
+        }
+        let totalCalls = 0;
+        let successCalls = 0;
+        let failureCalls = 0;
+        let totalResponseTime = 0;
+        let minResponseTime = Infinity;
+        let maxResponseTime = 0;
+        let maxP50 = 0;
+        let maxP95 = 0;
+        let maxP99 = 0;
+        for (const s of snapshots) {
+            totalCalls += s.totalCalls;
+            successCalls += s.successCalls;
+            failureCalls += s.failureCalls;
+            totalResponseTime += s.averageResponseTime * s.totalCalls;
+            minResponseTime = Math.min(minResponseTime, s.minResponseTime || Infinity);
+            maxResponseTime = Math.max(maxResponseTime, s.maxResponseTime);
+            maxP50 = Math.max(maxP50, s.p50ResponseTime);
+            maxP95 = Math.max(maxP95, s.p95ResponseTime);
+            maxP99 = Math.max(maxP99, s.p99ResponseTime);
+        }
+        return {
+            totalCalls,
+            successCalls,
+            failureCalls,
+            failureRate: totalCalls > 0 ? (failureCalls / totalCalls) * 100 : 0,
+            averageResponseTime: totalCalls > 0 ? totalResponseTime / totalCalls : 0,
+            p50ResponseTime: maxP50,
+            p95ResponseTime: maxP95,
+            p99ResponseTime: maxP99,
+            minResponseTime: minResponseTime === Infinity ? 0 : minResponseTime,
+            maxResponseTime,
+        };
+    }
+}
+exports.GatewayMetrics = GatewayMetrics;

package/dist/middleware/traffic-mirror.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Traffic Mirror
+ * Sends shadow copies of requests to a secondary service for testing
+ * without affecting the primary response.
+ */
+import { DiscoveryClient } from '@hazeljs/discovery';
+import { TrafficMirrorConfig, ProxyRequest } from '../types';
+export declare class TrafficMirror {
+    private config;
+    private discoveryClient;
+    private axiosInstance;
+    constructor(config: TrafficMirrorConfig, discoveryClient: DiscoveryClient);
+    /**
+     * Mirror a request to the shadow service.
+     * Fire-and-forget unless waitForResponse is true.
+     */
+    mirror(request: ProxyRequest): Promise<void>;
+}
+//# sourceMappingURL=traffic-mirror.d.ts.map

package/dist/middleware/traffic-mirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traffic-mirror.d.ts","sourceRoot":"","sources":["../../src/middleware/traffic-mirror.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7D,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,aAAa,CAAgB;gBAEzB,MAAM,EAAE,mBAAmB,EAAE,eAAe,EAAE,eAAe;IAMzE;;;OAGG;IACG,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;CAsCnD"}

package/dist/middleware/traffic-mirror.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Traffic Mirror
+ * Sends shadow copies of requests to a secondary service for testing
+ * without affecting the primary response.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrafficMirror = void 0;
+const axios_1 = __importDefault(require("axios"));
+class TrafficMirror {
+    constructor(config, discoveryClient) {
+        this.config = config;
+        this.discoveryClient = discoveryClient;
+        this.axiosInstance = axios_1.default.create({ timeout: 5000 });
+    }
+    /**
+     * Mirror a request to the shadow service.
+     * Fire-and-forget unless waitForResponse is true.
+     */
+    async mirror(request) {
+        // Check if this request should be mirrored (based on percentage)
+        if (Math.random() * 100 > this.config.percentage) {
+            return;
+        }
+        const mirrorFn = async () => {
+            try {
+                const instance = await this.discoveryClient.getInstance(this.config.service);
+                if (!instance)
+                    return;
+                const baseURL = `${instance.protocol || 'http'}://${instance.host}:${instance.port}`;
+                await this.axiosInstance.request({
+                    method: request.method,
+                    url: request.path,
+                    baseURL,
+                    headers: {
+                        ...request.headers,
+                        'X-Mirror': 'true',
+                        'X-Mirror-Source': 'hazeljs-gateway',
+                    },
+                    data: request.body,
+                    params: request.query,
+                });
+            }
+            catch {
+                // Silently ignore mirror failures — they must not affect the primary flow
+            }
+        };
+        if (this.config.waitForResponse) {
+            await mirrorFn();
+        }
+        else {
+            // Fire and forget
+            mirrorFn();
+        }
+    }
+}
+exports.TrafficMirror = TrafficMirror;

package/dist/proxy/service-proxy.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Service Proxy
+ * Enhanced HTTP client that integrates discovery, resilience, and traffic policies.
+ * The core request engine of the gateway.
+ */
+import { DiscoveryClient, ServiceFilter } from '@hazeljs/discovery';
+import { CircuitBreaker, MetricsCollector, CircuitBreakerConfig, RetryConfig, RateLimiterConfig } from '@hazeljs/resilience';
+import { ProxyRequest, ProxyResponse, TrafficTransformConfig } from '../types';
+export interface ServiceProxyConfig {
+    /** Service name in the discovery registry */
+    serviceName: string;
+    /** Load balancing strategy */
+    loadBalancingStrategy?: string;
+    /** Service instance filter */
+    filter?: ServiceFilter;
+    /** Strip this prefix from the path before forwarding */
+    stripPrefix?: string;
+    /** Add this prefix to the path when forwarding */
+    addPrefix?: string;
+    /** Request timeout in ms */
+    timeout?: number;
+    /** Retry configuration */
+    retry?: Partial<RetryConfig>;
+    /** Circuit breaker configuration */
+    circuitBreaker?: Partial<CircuitBreakerConfig>;
+    /** Rate limiter configuration */
+    rateLimit?: Partial<RateLimiterConfig>;
+    /** Request/response transformers */
+    transform?: TrafficTransformConfig;
+}
+export declare class ServiceProxy {
+    private discoveryClient;
+    private axiosInstance;
+    private retryPolicy?;
+    private circuitBreaker?;
+    private timeout?;
+    private rateLimiter?;
+    private metrics;
+    private config;
+    constructor(discoveryClient: DiscoveryClient, config: ServiceProxyConfig);
+    /**
+     * Forward an incoming request to the target service
+     */
+    forward(request: ProxyRequest): Promise<ProxyResponse>;
+    /**
+     * Forward a request with a specific version filter
+     */
+    forwardToVersion(request: ProxyRequest, version: string, additionalFilter?: ServiceFilter): Promise<ProxyResponse>;
+    /**
+     * Forward with a custom filter override
+     */
+    forwardWithFilter(request: ProxyRequest, filter: ServiceFilter): Promise<ProxyResponse>;
+    /**
+     * Get the metrics collector for this proxy
+     */
+    getMetrics(): MetricsCollector;
+    /**
+     * Get the circuit breaker instance (if configured)
+     */
+    getCircuitBreaker(): CircuitBreaker | undefined;
+    /**
+     * Get the service name this proxy routes to
+     */
+    getServiceName(): string;
+    private doForward;
+    private doForwardToInstance;
+}
+//# sourceMappingURL=service-proxy.d.ts.map

package/dist/proxy/service-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-proxy.d.ts","sourceRoot":"","sources":["../../src/proxy/service-proxy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,eAAe,EAAmB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACrF,OAAO,EACL,cAAc,EAMd,gBAAgB,EAChB,oBAAoB,EACpB,WAAW,EACX,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,8BAA8B;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7B,oCAAoC;IACpC,cAAc,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC/C,iCAAiC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvC,oCAAoC;IACpC,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,OAAO,CAAC,CAAU;IAC1B,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,MAAM,CAAqB;gBAEvB,eAAe,EAAE,eAAe,EAAE,MAAM,EAAE,kBAAkB;IA6BxE;;OAEG;IACG,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAgE5D;;OAEG;IACG,gBAAgB,CACpB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,aAAa,GAC/B,OAAO,CAAC,aAAa,CAAC;IAczB;;OAEG;IACG,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAc7F;;OAEG;IACH,UAAU,IAAI,gBAAgB;IAI9B;;OAEG;IACH,iBAAiB,IAAI,cAAc,GAAG,SAAS;IAI/C;;OAEG;IACH,cAAc,IAAI,MAAM;YAMV,SAAS;YAcT,mBAAmB;CA0ElC"}