@hazeljs/gateway 0.2.0-beta.41

package/dist/__tests__/version-router.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const version_router_1 = require("../routing/version-router");
+function makeRequest(overrides = {}) {
+    return {
+        method: 'GET',
+        path: '/api/test',
+        headers: {},
+        ...overrides,
+    };
+}
+describe('VersionRouter', () => {
+    describe('header-based routing', () => {
+        it('should resolve version from header', () => {
+            const router = new version_router_1.VersionRouter({
+                header: 'X-API-Version',
+                routes: {
+                    v1: { weight: 80 },
+                    v2: { weight: 20 },
+                },
+            });
+            const result = router.resolve(makeRequest({ headers: { 'X-API-Version': 'v2' } }));
+            expect(result.version).toBe('v2');
+            expect(result.resolvedBy).toBe('header');
+        });
+        it('should resolve explicitly allowed version even with 0 weight', () => {
+            const router = new version_router_1.VersionRouter({
+                header: 'X-API-Version',
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0, allowExplicit: true },
+                },
+            });
+            const result = router.resolve(makeRequest({ headers: { 'X-API-Version': 'v2' } }));
+            expect(result.version).toBe('v2');
+            expect(result.resolvedBy).toBe('header');
+        });
+        it('should not resolve version with 0 weight and no allowExplicit', () => {
+            const router = new version_router_1.VersionRouter({
+                header: 'X-API-Version',
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0 },
+                },
+            });
+            // Header says v2 but it's not explicitly allowed
+            const result = router.resolve(makeRequest({ headers: { 'X-API-Version': 'v2' } }));
+            expect(result.version).toBe('v1');
+            expect(result.resolvedBy).toBe('weight');
+        });
+    });
+    describe('weighted routing', () => {
+        it('should fall back to weighted routing when no explicit version', () => {
+            const router = new version_router_1.VersionRouter({
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0 },
+                },
+            });
+            const result = router.resolve(makeRequest());
+            expect(result.version).toBe('v1');
+            expect(result.resolvedBy).toBe('weight');
+        });
+        it('should distribute based on weights', () => {
+            const router = new version_router_1.VersionRouter({
+                routes: {
+                    v1: { weight: 50 },
+                    v2: { weight: 50 },
+                },
+            });
+            const counts = { v1: 0, v2: 0 };
+            for (let i = 0; i < 1000; i++) {
+                const result = router.resolve(makeRequest());
+                counts[result.version]++;
+            }
+            // With 50/50 weight over 1000 runs, each should be roughly 500
+            expect(counts['v1']).toBeGreaterThan(350);
+            expect(counts['v2']).toBeGreaterThan(350);
+        });
+    });
+    describe('default version', () => {
+        it('should use defaultVersion when no other resolution works', () => {
+            const router = new version_router_1.VersionRouter({
+                defaultVersion: 'v1',
+                routes: {
+                    v1: { weight: 0 },
+                    v2: { weight: 0 },
+                },
+            });
+            const result = router.resolve(makeRequest());
+            expect(result.version).toBe('v1');
+            expect(result.resolvedBy).toBe('default');
+        });
+    });
+    describe('URI-based routing', () => {
+        it('should resolve version from URI path', () => {
+            const router = new version_router_1.VersionRouter({
+                strategy: 'uri',
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0, allowExplicit: true },
+                },
+            });
+            const result = router.resolve(makeRequest({ path: '/v2/api/test' }));
+            expect(result.version).toBe('v2');
+            expect(result.resolvedBy).toBe('uri');
+        });
+    });
+    describe('query-based routing', () => {
+        it('should resolve version from query parameter', () => {
+            const router = new version_router_1.VersionRouter({
+                strategy: 'query',
+                queryParam: 'version',
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0, allowExplicit: true },
+                },
+            });
+            const result = router.resolve(makeRequest({ query: { version: 'v2' } }));
+            expect(result.version).toBe('v2');
+            expect(result.resolvedBy).toBe('query');
+        });
+    });
+    describe('getVersions', () => {
+        it('should return all configured versions', () => {
+            const router = new version_router_1.VersionRouter({
+                routes: {
+                    v1: { weight: 50 },
+                    v2: { weight: 50 },
+                    v3: { weight: 0 },
+                },
+            });
+            expect(router.getVersions()).toEqual(['v1', 'v2', 'v3']);
+        });
+    });
+});

package/dist/canary/canary-engine.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Canary Deployment Engine
+ *
+ * The differentiator feature of @hazeljs/gateway.
+ *
+ * Tracks real-time error rates and latency per service version,
+ * automatically promotes canary traffic through configurable steps,
+ * and rolls back if error thresholds are breached.
+ *
+ * States:
+ *   ACTIVE     -> canary is receiving traffic at current weight
+ *   PROMOTED   -> canary promoted to 100%, rollout complete
+ *   ROLLED_BACK -> canary failed, all traffic to stable
+ *   PAUSED     -> manual pause, no automatic transitions
+ */
+import { EventEmitter } from 'events';
+import { CanaryConfig, CanaryState, CanaryMetrics, ProxyRequest } from '../types';
+export interface CanaryStatus {
+    state: CanaryState;
+    stableVersion: string;
+    canaryVersion: string;
+    currentStableWeight: number;
+    currentCanaryWeight: number;
+    currentStep: number;
+    totalSteps: number;
+    metrics: CanaryMetrics;
+    lastEvaluation?: Date;
+    lastTransition?: Date;
+}
+export declare class CanaryEngine extends EventEmitter {
+    private state;
+    private config;
+    private stableMetrics;
+    private canaryMetrics;
+    private currentStableWeight;
+    private currentCanaryWeight;
+    private currentStepIndex;
+    private evaluationTimer?;
+    private promotionTimer?;
+    private lastEvaluation?;
+    private lastTransition?;
+    private evaluationWindowMs;
+    private stepIntervalMs;
+    constructor(config: CanaryConfig);
+    /**
+     * Start the canary evaluation loop
+     */
+    start(): void;
+    /**
+     * Stop the canary evaluation loop
+     */
+    stop(): void;
+    /**
+     * Route a request: returns 'stable' or 'canary' based on current weights
+     */
+    selectVersion(_request: ProxyRequest): 'stable' | 'canary';
+    /**
+     * Record a successful request for a version
+     */
+    recordSuccess(target: 'stable' | 'canary', duration: number): void;
+    /**
+     * Record a failed request for a version
+     */
+    recordFailure(target: 'stable' | 'canary', duration: number, error?: string): void;
+    /**
+     * Get the current canary status
+     */
+    getStatus(): CanaryStatus;
+    /**
+     * Get current metrics for both versions
+     */
+    getMetrics(): CanaryMetrics;
+    /**
+     * Get the version string for a target
+     */
+    getVersion(target: 'stable' | 'canary'): string;
+    /**
+     * Manually promote to the next step
+     */
+    promote(): void;
+    /**
+     * Manually rollback the canary
+     */
+    rollback(): void;
+    /**
+     * Manually pause the canary
+     */
+    pause(): void;
+    /**
+     * Resume a paused canary
+     */
+    resume(): void;
+    private evaluate;
+    private makeDecision;
+    private evaluateByErrorRate;
+    private evaluateByLatency;
+    private schedulePromotion;
+    private doPromote;
+    private doRollback;
+    private findStepIndex;
+}
+/**
+ * Parse an interval string like '5m', '10s', '1h' to milliseconds.
+ * Also accepts raw numbers (treated as ms).
+ */
+export declare function parseInterval(value: number | string): number;
+//# sourceMappingURL=canary-engine.d.ts.map

package/dist/canary/canary-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canary-engine.d.ts","sourceRoot":"","sources":["../../src/canary/canary-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAkB,YAAY,EAAE,MAAM,UAAU,CAAC;AAElG,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,cAAc,CAAC,EAAE,IAAI,CAAC;CACvB;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,eAAe,CAAC,CAAiB;IACzC,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,cAAc,CAAC,CAAO;IAC9B,OAAO,CAAC,cAAc,CAAC,CAAO;IAC9B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,cAAc,CAAS;gBAEnB,MAAM,EAAE,YAAY;IAiBhC;;OAEG;IACH,KAAK,IAAI,IAAI;IAeb;;OAEG;IACH,IAAI,IAAI,IAAI;IAWZ;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,QAAQ,GAAG,QAAQ;IAS1D;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQlE;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAQlF;;OAEG;IACH,SAAS,IAAI,YAAY;IAezB;;OAEG;IACH,UAAU,IAAI,aAAa;IAsB3B;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM;IAI/C;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;OAEG;IACH,QAAQ,IAAI,IAAI;IAIhB;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,MAAM,IAAI,IAAI;IASd,OAAO,CAAC,QAAQ;IA+BhB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,SAAS;IAkCjB,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,aAAa;CAOtB;AAID;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAyB5D"}

package/dist/canary/canary-engine.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Canary Deployment Engine
+ *
+ * The differentiator feature of @hazeljs/gateway.
+ *
+ * Tracks real-time error rates and latency per service version,
+ * automatically promotes canary traffic through configurable steps,
+ * and rolls back if error thresholds are breached.
+ *
+ * States:
+ *   ACTIVE     -> canary is receiving traffic at current weight
+ *   PROMOTED   -> canary promoted to 100%, rollout complete
+ *   ROLLED_BACK -> canary failed, all traffic to stable
+ *   PAUSED     -> manual pause, no automatic transitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanaryEngine = void 0;
+exports.parseInterval = parseInterval;
+const events_1 = require("events");
+const resilience_1 = require("@hazeljs/resilience");
+const types_1 = require("../types");
+class CanaryEngine extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.state = types_1.CanaryState.ACTIVE;
+        this.currentStepIndex = 0;
+        this.config = config;
+        this.currentStableWeight = config.stable.weight;
+        this.currentCanaryWeight = config.canary.weight;
+        this.evaluationWindowMs = parseInterval(config.promotion.evaluationWindow);
+        this.stepIntervalMs = parseInterval(config.promotion.stepInterval);
+        // Initialize metrics collectors with evaluation window
+        this.stableMetrics = new resilience_1.MetricsCollector(this.evaluationWindowMs);
+        this.canaryMetrics = new resilience_1.MetricsCollector(this.evaluationWindowMs);
+        // Find the initial step index based on current canary weight
+        this.currentStepIndex = this.findStepIndex(config.canary.weight);
+    }
+    /**
+     * Start the canary evaluation loop
+     */
+    start() {
+        if (this.state !== types_1.CanaryState.ACTIVE)
+            return;
+        // Schedule periodic evaluation
+        this.evaluationTimer = setInterval(() => {
+            this.evaluate();
+        }, this.evaluationWindowMs);
+        this.emit('canary:started', {
+            stable: this.config.stable.version,
+            canary: this.config.canary.version,
+            weight: this.currentCanaryWeight,
+        });
+    }
+    /**
+     * Stop the canary evaluation loop
+     */
+    stop() {
+        if (this.evaluationTimer) {
+            clearInterval(this.evaluationTimer);
+            this.evaluationTimer = undefined;
+        }
+        if (this.promotionTimer) {
+            clearTimeout(this.promotionTimer);
+            this.promotionTimer = undefined;
+        }
+    }
+    /**
+     * Route a request: returns 'stable' or 'canary' based on current weights
+     */
+    selectVersion(_request) {
+        if (this.state === types_1.CanaryState.ROLLED_BACK)
+            return 'stable';
+        if (this.state === types_1.CanaryState.PROMOTED)
+            return 'canary';
+        // Weighted random selection
+        const random = Math.random() * 100;
+        return random < this.currentCanaryWeight ? 'canary' : 'stable';
+    }
+    /**
+     * Record a successful request for a version
+     */
+    recordSuccess(target, duration) {
+        if (target === 'stable') {
+            this.stableMetrics.recordSuccess(duration);
+        }
+        else {
+            this.canaryMetrics.recordSuccess(duration);
+        }
+    }
+    /**
+     * Record a failed request for a version
+     */
+    recordFailure(target, duration, error) {
+        if (target === 'stable') {
+            this.stableMetrics.recordFailure(duration, error);
+        }
+        else {
+            this.canaryMetrics.recordFailure(duration, error);
+        }
+    }
+    /**
+     * Get the current canary status
+     */
+    getStatus() {
+        return {
+            state: this.state,
+            stableVersion: this.config.stable.version,
+            canaryVersion: this.config.canary.version,
+            currentStableWeight: this.currentStableWeight,
+            currentCanaryWeight: this.currentCanaryWeight,
+            currentStep: this.currentStepIndex,
+            totalSteps: this.config.promotion.steps.length,
+            metrics: this.getMetrics(),
+            lastEvaluation: this.lastEvaluation,
+            lastTransition: this.lastTransition,
+        };
+    }
+    /**
+     * Get current metrics for both versions
+     */
+    getMetrics() {
+        const stableSnapshot = this.stableMetrics.getSnapshot();
+        const canarySnapshot = this.canaryMetrics.getSnapshot();
+        return {
+            stable: {
+                totalRequests: stableSnapshot.totalCalls,
+                errorCount: stableSnapshot.failureCalls,
+                errorRate: stableSnapshot.failureRate,
+                averageLatency: stableSnapshot.averageResponseTime,
+                p99Latency: stableSnapshot.p99ResponseTime,
+            },
+            canary: {
+                totalRequests: canarySnapshot.totalCalls,
+                errorCount: canarySnapshot.failureCalls,
+                errorRate: canarySnapshot.failureRate,
+                averageLatency: canarySnapshot.averageResponseTime,
+                p99Latency: canarySnapshot.p99ResponseTime,
+            },
+        };
+    }
+    /**
+     * Get the version string for a target
+     */
+    getVersion(target) {
+        return target === 'stable' ? this.config.stable.version : this.config.canary.version;
+    }
+    /**
+     * Manually promote to the next step
+     */
+    promote() {
+        this.doPromote();
+    }
+    /**
+     * Manually rollback the canary
+     */
+    rollback() {
+        this.doRollback('manual');
+    }
+    /**
+     * Manually pause the canary
+     */
+    pause() {
+        this.state = types_1.CanaryState.PAUSED;
+        this.stop();
+        this.emit('canary:paused', this.getStatus());
+    }
+    /**
+     * Resume a paused canary
+     */
+    resume() {
+        if (this.state !== types_1.CanaryState.PAUSED)
+            return;
+        this.state = types_1.CanaryState.ACTIVE;
+        this.start();
+        this.emit('canary:resumed', this.getStatus());
+    }
+    // ─── Evaluation ───
+    evaluate() {
+        if (this.state !== types_1.CanaryState.ACTIVE)
+            return;
+        this.lastEvaluation = new Date();
+        const metrics = this.getMetrics();
+        // Check minimum requests threshold
+        const minRequests = this.config.promotion.minRequests ?? 10;
+        if (metrics.canary.totalRequests < minRequests) {
+            return; // Not enough data to evaluate
+        }
+        const decision = this.makeDecision(metrics);
+        switch (decision) {
+            case 'promote':
+                if (this.config.promotion.autoPromote) {
+                    this.schedulePromotion();
+                }
+                break;
+            case 'rollback':
+                if (this.config.promotion.autoRollback) {
+                    this.doRollback('auto');
+                }
+                break;
+            case 'hold':
+                // Do nothing, wait for next evaluation
+                break;
+        }
+    }
+    makeDecision(metrics) {
+        // Custom evaluator takes priority
+        if (this.config.promotion.customEvaluator) {
+            return this.config.promotion.customEvaluator(metrics);
+        }
+        const strategy = this.config.promotion.strategy;
+        if (strategy === 'error-rate') {
+            return this.evaluateByErrorRate(metrics);
+        }
+        if (strategy === 'latency') {
+            return this.evaluateByLatency(metrics);
+        }
+        return 'hold';
+    }
+    evaluateByErrorRate(metrics) {
+        const threshold = this.config.promotion.errorThreshold ?? 5;
+        // If canary error rate exceeds threshold, rollback
+        if (metrics.canary.errorRate > threshold) {
+            return 'rollback';
+        }
+        // If canary error rate is within threshold, promote
+        if (metrics.canary.errorRate <= threshold) {
+            return 'promote';
+        }
+        return 'hold';
+    }
+    evaluateByLatency(metrics) {
+        const threshold = this.config.promotion.latencyThreshold ?? 1000;
+        // If canary p99 latency exceeds threshold, rollback
+        if (metrics.canary.p99Latency > threshold) {
+            return 'rollback';
+        }
+        // If canary latency is acceptable, promote
+        return 'promote';
+    }
+    schedulePromotion() {
+        // If already at the last step, we're done
+        if (this.currentStepIndex >= this.config.promotion.steps.length - 1) {
+            this.doPromote();
+            return;
+        }
+        // If a promotion is already scheduled, don't double-schedule
+        if (this.promotionTimer)
+            return;
+        // Schedule the next step
+        this.promotionTimer = setTimeout(() => {
+            this.promotionTimer = undefined;
+            this.doPromote();
+        }, this.stepIntervalMs);
+    }
+    doPromote() {
+        if (this.state !== types_1.CanaryState.ACTIVE)
+            return;
+        this.currentStepIndex++;
+        this.lastTransition = new Date();
+        if (this.currentStepIndex >= this.config.promotion.steps.length) {
+            // Fully promoted
+            this.currentCanaryWeight = 100;
+            this.currentStableWeight = 0;
+            this.state = types_1.CanaryState.PROMOTED;
+            this.stop();
+            this.emit('canary:complete', {
+                version: this.config.canary.version,
+                metrics: this.getMetrics(),
+            });
+            return;
+        }
+        // Move to the next weight step
+        const newWeight = this.config.promotion.steps[this.currentStepIndex];
+        this.currentCanaryWeight = newWeight;
+        this.currentStableWeight = 100 - newWeight;
+        this.emit('canary:promote', {
+            step: this.currentStepIndex,
+            totalSteps: this.config.promotion.steps.length,
+            canaryWeight: this.currentCanaryWeight,
+            stableWeight: this.currentStableWeight,
+            metrics: this.getMetrics(),
+        });
+    }
+    doRollback(trigger) {
+        this.state = types_1.CanaryState.ROLLED_BACK;
+        this.currentCanaryWeight = 0;
+        this.currentStableWeight = 100;
+        this.lastTransition = new Date();
+        this.stop();
+        this.emit('canary:rollback', {
+            trigger,
+            canaryVersion: this.config.canary.version,
+            stableVersion: this.config.stable.version,
+            metrics: this.getMetrics(),
+        });
+    }
+    findStepIndex(weight) {
+        const steps = this.config.promotion.steps;
+        for (let i = 0; i < steps.length; i++) {
+            if (steps[i] >= weight)
+                return i;
+        }
+        return 0;
+    }
+}
+exports.CanaryEngine = CanaryEngine;
+// ─── Utilities ───
+/**
+ * Parse an interval string like '5m', '10s', '1h' to milliseconds.
+ * Also accepts raw numbers (treated as ms).
+ */
+function parseInterval(value) {
+    if (typeof value === 'number')
+        return value;
+    const match = value.match(/^(\d+)(ms|s|m|h)$/);
+    if (!match) {
+        throw new Error(`Invalid interval format: "${value}". Use formats like "5m", "30s", "1h", or a number in ms.`);
+    }
+    const amount = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 'ms':
+            return amount;
+        case 's':
+            return amount * 1000;
+        case 'm':
+            return amount * 60 * 1000;
+        case 'h':
+            return amount * 60 * 60 * 1000;
+        default:
+            return amount;
+    }
+}

package/dist/decorators/index.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Gateway Decorators
+ * Declarative API for defining gateway routes and policies.
+ */
+import 'reflect-metadata';
+import { GatewayConfig, RouteConfig, ServiceRouteConfig, VersionRouteConfig, CanaryConfig, TrafficPolicyConfig } from '../types';
+import { CircuitBreakerConfig, RateLimiterConfig } from '@hazeljs/resilience';
+type Constructor = new (...args: unknown[]) => unknown;
+/**
+ * @Gateway class decorator
+ * Marks a class as a gateway definition with global configuration.
+ */
+export declare function Gateway(config: GatewayConfig): ClassDecorator;
+/**
+ * @Route property/method decorator
+ * Defines a URL pattern this route handles.
+ */
+export declare function Route(pathOrConfig: string | RouteConfig): PropertyDecorator;
+/**
+ * @ServiceRoute property/method decorator
+ * Maps this route to a service in the discovery registry.
+ */
+export declare function ServiceRoute(nameOrConfig: string | ServiceRouteConfig): PropertyDecorator;
+/**
+ * @VersionRoute property/method decorator
+ * Enables version-based routing for this route.
+ */
+export declare function VersionRoute(config: VersionRouteConfig): PropertyDecorator;
+/**
+ * @Canary property/method decorator
+ * Enables canary deployment for this route.
+ */
+export declare function Canary(config: CanaryConfig): PropertyDecorator;
+/**
+ * @TrafficPolicy property/method decorator
+ * Defines traffic policies (mirroring, transformation, etc.)
+ */
+export declare function TrafficPolicy(config: TrafficPolicyConfig): PropertyDecorator;
+/**
+ * @CircuitBreaker property decorator (gateway-specific)
+ * Overrides circuit breaker configuration for this route.
+ */
+export declare function GatewayCircuitBreaker(config: Partial<CircuitBreakerConfig>): PropertyDecorator;
+/**
+ * @RateLimit property decorator (gateway-specific)
+ * Overrides rate limit configuration for this route.
+ */
+export declare function GatewayRateLimit(config: Partial<RateLimiterConfig>): PropertyDecorator;
+export declare function getGatewayConfig(target: Constructor): GatewayConfig | undefined;
+export declare function getRouteConfig(target: object, propertyKey: string | symbol): RouteConfig | undefined;
+export declare function getServiceRouteConfig(target: object, propertyKey: string | symbol): ServiceRouteConfig | undefined;
+export declare function getVersionRouteConfig(target: object, propertyKey: string | symbol): VersionRouteConfig | undefined;
+export declare function getCanaryConfig(target: object, propertyKey: string | symbol): CanaryConfig | undefined;
+export declare function getTrafficPolicyConfig(target: object, propertyKey: string | symbol): TrafficPolicyConfig | undefined;
+export declare function getCircuitBreakerConfig(target: object, propertyKey: string | symbol): Partial<CircuitBreakerConfig> | undefined;
+export declare function getRateLimitConfig(target: object, propertyKey: string | symbol): Partial<RateLimiterConfig> | undefined;
+/**
+ * Collect all route definitions from a gateway class instance
+ */
+export declare function collectRouteDefinitions(gatewayClass: Constructor): {
+    config: GatewayConfig;
+    routes: Array<{
+        propertyKey: string;
+        route?: RouteConfig;
+        serviceRoute?: ServiceRouteConfig;
+        versionRoute?: VersionRouteConfig;
+        canary?: CanaryConfig;
+        trafficPolicy?: TrafficPolicyConfig;
+        circuitBreaker?: Partial<CircuitBreakerConfig>;
+        rateLimit?: Partial<RateLimiterConfig>;
+    }>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"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"}