@hazeljs/gateway 0.2.0-beta.41

package/dist/__tests__/decorators.test.js

@@ -0,0 +1,174 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const decorators_1 = require("../decorators");
+describe('Gateway Decorators', () => {
+    it('should collect gateway config from class', () => {
+        let TestGateway = class TestGateway {
+        };
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({
+                discovery: { cacheEnabled: true },
+                metrics: { enabled: true },
+            })
+        ], TestGateway);
+        const { config } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(config.discovery?.cacheEnabled).toBe(true);
+        expect(config.metrics?.enabled).toBe(true);
+    });
+    it('should collect route definitions from properties', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/users/**'),
+            (0, decorators_1.ServiceRoute)('user-service'),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "userService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes).toHaveLength(1);
+        expect(routes[0].route?.path).toBe('/api/users/**');
+        expect(routes[0].serviceRoute?.serviceName).toBe('user-service');
+    });
+    it('should collect canary config', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/orders/**'),
+            (0, decorators_1.ServiceRoute)('order-service'),
+            (0, decorators_1.Canary)({
+                stable: { version: 'v1', weight: 90 },
+                canary: { version: 'v2', weight: 10 },
+                promotion: {
+                    strategy: 'error-rate',
+                    errorThreshold: 5,
+                    evaluationWindow: '5m',
+                    autoPromote: true,
+                    autoRollback: true,
+                    steps: [10, 25, 50, 75, 100],
+                    stepInterval: '10m',
+                },
+            }),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "orderService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes[0].canary).toBeDefined();
+        expect(routes[0].canary.stable.version).toBe('v1');
+        expect(routes[0].canary.canary.version).toBe('v2');
+        expect(routes[0].canary.promotion.steps).toEqual([10, 25, 50, 75, 100]);
+    });
+    it('should collect version route config', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/payments/**'),
+            (0, decorators_1.ServiceRoute)('payment-service'),
+            (0, decorators_1.VersionRoute)({
+                header: 'X-API-Version',
+                routes: {
+                    v1: { weight: 100 },
+                    v2: { weight: 0, allowExplicit: true },
+                },
+            }),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "paymentService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes[0].versionRoute).toBeDefined();
+        expect(routes[0].versionRoute.header).toBe('X-API-Version');
+        expect(routes[0].versionRoute.routes['v1'].weight).toBe(100);
+        expect(routes[0].versionRoute.routes['v2'].allowExplicit).toBe(true);
+    });
+    it('should collect traffic policy', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/search/**'),
+            (0, decorators_1.ServiceRoute)('search-service'),
+            (0, decorators_1.TrafficPolicy)({
+                mirror: { service: 'search-v2', percentage: 10 },
+                timeout: 3000,
+            }),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "searchService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes[0].trafficPolicy).toBeDefined();
+        expect(routes[0].trafficPolicy.mirror?.service).toBe('search-v2');
+        expect(routes[0].trafficPolicy.mirror?.percentage).toBe(10);
+        expect(routes[0].trafficPolicy.timeout).toBe(3000);
+    });
+    it('should collect circuit breaker and rate limit overrides', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/critical/**'),
+            (0, decorators_1.ServiceRoute)('critical-service'),
+            (0, decorators_1.GatewayCircuitBreaker)({ failureThreshold: 3 }),
+            (0, decorators_1.GatewayRateLimit)({ strategy: 'sliding-window', max: 50, window: 60000 }),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "criticalService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes[0].circuitBreaker?.failureThreshold).toBe(3);
+        expect(routes[0].rateLimit?.max).toBe(50);
+    });
+    it('should handle multiple routes', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/a/**'),
+            (0, decorators_1.ServiceRoute)('service-a'),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "serviceA", void 0);
+        __decorate([
+            (0, decorators_1.Route)('/api/b/**'),
+            (0, decorators_1.ServiceRoute)('service-b'),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "serviceB", void 0);
+        __decorate([
+            (0, decorators_1.Route)('/api/c/**'),
+            (0, decorators_1.ServiceRoute)('service-c'),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "serviceC", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes).toHaveLength(3);
+    });
+    it('should accept string shorthand for ServiceRoute', () => {
+        let TestGateway = class TestGateway {
+        };
+        __decorate([
+            (0, decorators_1.Route)('/api/simple/**'),
+            (0, decorators_1.ServiceRoute)('simple-service'),
+            __metadata("design:type", Object)
+        ], TestGateway.prototype, "simpleService", void 0);
+        TestGateway = __decorate([
+            (0, decorators_1.Gateway)({})
+        ], TestGateway);
+        const { routes } = (0, decorators_1.collectRouteDefinitions)(TestGateway);
+        expect(routes[0].serviceRoute?.serviceName).toBe('simple-service');
+    });
+});

package/dist/__tests__/from-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=from-config.test.d.ts.map

package/dist/__tests__/from-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-config.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/from-config.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/from-config.test.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gateway_1 = require("../gateway");
+describe('GatewayServer.fromConfig', () => {
+    const config = {
+        discovery: { cacheEnabled: false },
+        resilience: {
+            defaultTimeout: 5000,
+            defaultCircuitBreaker: { failureThreshold: 5, resetTimeout: 30000 },
+        },
+        routes: [
+            {
+                path: '/api/users/**',
+                serviceName: 'user-service',
+                serviceConfig: {
+                    serviceName: 'user-service',
+                    stripPrefix: '/api/users',
+                    addPrefix: '/users',
+                },
+                circuitBreaker: { failureThreshold: 10 },
+                rateLimit: { strategy: 'sliding-window', max: 100, window: 60000 },
+            },
+            {
+                path: '/api/orders/**',
+                serviceName: 'order-service',
+                canary: {
+                    stable: { version: 'v1', weight: 90 },
+                    canary: { version: 'v2', weight: 10 },
+                    promotion: {
+                        strategy: 'error-rate',
+                        errorThreshold: 5,
+                        evaluationWindow: '5m',
+                        autoPromote: true,
+                        autoRollback: true,
+                        steps: [10, 25, 50, 75, 100],
+                        stepInterval: '10m',
+                    },
+                },
+            },
+        ],
+    };
+    it('should create a gateway with all routes from config', () => {
+        const gateway = gateway_1.GatewayServer.fromConfig(config);
+        const routes = gateway.getRoutes();
+        expect(routes).toContain('/api/users/**');
+        expect(routes).toContain('/api/orders/**');
+        expect(routes).toHaveLength(2);
+    });
+    it('should set up canary engine for routes with canary config', () => {
+        const gateway = gateway_1.GatewayServer.fromConfig(config);
+        const canaryEngine = gateway.getCanaryEngine('/api/orders/**');
+        expect(canaryEngine).toBeDefined();
+        // No canary for users route
+        const noCanary = gateway.getCanaryEngine('/api/users/**');
+        expect(noCanary).toBeUndefined();
+    });
+    it('should create a working gateway with empty routes', () => {
+        const emptyConfig = {
+            routes: [],
+        };
+        const gateway = gateway_1.GatewayServer.fromConfig(emptyConfig);
+        expect(gateway.getRoutes()).toHaveLength(0);
+    });
+    afterEach(() => {
+        // Clean up to avoid state leaks between tests
+    });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gateway-metrics.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-metrics.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/gateway-metrics.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/gateway-metrics.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gateway_metrics_1 = require("../metrics/gateway-metrics");
+describe('GatewayMetrics', () => {
+    let metrics;
+    beforeEach(() => {
+        metrics = new gateway_metrics_1.GatewayMetrics(60000);
+    });
+    describe('recordSuccess / recordFailure', () => {
+        it('should record success for a route', () => {
+            metrics.recordSuccess('/api/users', 50);
+            metrics.recordSuccess('/api/users', 100);
+            const snapshot = metrics.getRouteMetrics('/api/users');
+            expect(snapshot).toBeDefined();
+            expect(snapshot.totalCalls).toBe(2);
+            expect(snapshot.successCalls).toBe(2);
+            expect(snapshot.failureCalls).toBe(0);
+        });
+        it('should record failure for a route', () => {
+            metrics.recordFailure('/api/orders', 30, 'Timeout');
+            metrics.recordFailure('/api/orders', 50, '502');
+            const snapshot = metrics.getRouteMetrics('/api/orders');
+            expect(snapshot).toBeDefined();
+            expect(snapshot.totalCalls).toBe(2);
+            expect(snapshot.failureCalls).toBe(2);
+        });
+        it('should record success with version', () => {
+            metrics.recordSuccess('/api/users', 50, 'v1');
+            metrics.recordSuccess('/api/users', 80, 'v2');
+            const v1 = metrics.getVersionMetrics('/api/users', 'v1');
+            const v2 = metrics.getVersionMetrics('/api/users', 'v2');
+            expect(v1?.successCalls).toBe(1);
+            expect(v2?.successCalls).toBe(1);
+        });
+        it('should record failure with version', () => {
+            metrics.recordFailure('/api/users', 100, 'Error', 'v1');
+            const v1 = metrics.getVersionMetrics('/api/users', 'v1');
+            expect(v1?.failureCalls).toBe(1);
+        });
+    });
+    describe('getVersionErrorRate', () => {
+        it('should return 0 for non-existent version', () => {
+            expect(metrics.getVersionErrorRate('/api/x', 'v1')).toBe(0);
+        });
+        it('should return error rate for version with failures', () => {
+            metrics.recordSuccess('/api/x', 10, 'v1');
+            metrics.recordFailure('/api/x', 10, 'err', 'v1');
+            const rate = metrics.getVersionErrorRate('/api/x', 'v1');
+            expect(rate).toBe(50);
+        });
+    });
+    describe('getSnapshot', () => {
+        it('should return full snapshot with aggregated metrics', () => {
+            metrics.recordSuccess('/a', 50);
+            metrics.recordSuccess('/b', 100);
+            const snapshot = metrics.getSnapshot();
+            expect(snapshot.timestamp).toBeDefined();
+            expect(snapshot.totalRoutes).toBe(2);
+            expect(snapshot.routes).toHaveLength(2);
+            expect(snapshot.aggregated.totalCalls).toBe(2);
+            expect(snapshot.aggregated.successCalls).toBe(2);
+        });
+        it('should return empty aggregated when no routes', () => {
+            const snapshot = metrics.getSnapshot();
+            expect(snapshot.totalRoutes).toBe(0);
+            expect(snapshot.routes).toHaveLength(0);
+            expect(snapshot.aggregated.totalCalls).toBe(0);
+        });
+    });
+    describe('reset', () => {
+        it('should reset all metrics to zero', () => {
+            metrics.recordSuccess('/a', 50);
+            metrics.recordSuccess('/a', 100, 'v1');
+            metrics.reset();
+            const routeSnapshot = metrics.getRouteMetrics('/a');
+            const versionSnapshot = metrics.getVersionMetrics('/a', 'v1');
+            expect(routeSnapshot?.totalCalls).toBe(0);
+            expect(routeSnapshot?.successCalls).toBe(0);
+            expect(versionSnapshot?.totalCalls).toBe(0);
+        });
+    });
+});

package/dist/__tests__/gateway-module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gateway-module.test.d.ts.map

package/dist/__tests__/gateway-module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-module.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/gateway-module.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/gateway-module.test.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gateway_module_1 = require("../gateway.module");
+describe('GatewayModule', () => {
+    const sampleConfig = {
+        discovery: { cacheEnabled: true },
+        routes: [
+            {
+                path: '/api/users/**',
+                serviceName: 'user-service',
+            },
+            {
+                path: '/api/orders/**',
+                serviceName: 'order-service',
+                canary: {
+                    stable: { version: 'v1', weight: 90 },
+                    canary: { version: 'v2', weight: 10 },
+                    promotion: {
+                        strategy: 'error-rate',
+                        errorThreshold: 5,
+                        evaluationWindow: '5m',
+                        autoPromote: true,
+                        autoRollback: true,
+                        steps: [10, 25, 50, 75, 100],
+                        stepInterval: '10m',
+                    },
+                },
+            },
+        ],
+    };
+    describe('forRoot', () => {
+        it('should store options with default configKey', () => {
+            gateway_module_1.GatewayModule.forRoot({});
+            const opts = gateway_module_1.GatewayModule.getOptions();
+            expect(opts.configKey).toBe('gateway');
+        });
+        it('should allow custom configKey', () => {
+            gateway_module_1.GatewayModule.forRoot({ configKey: 'myGateway' });
+            const opts = gateway_module_1.GatewayModule.getOptions();
+            expect(opts.configKey).toBe('myGateway');
+        });
+        it('should accept direct config', () => {
+            gateway_module_1.GatewayModule.forRoot({ config: sampleConfig });
+            const opts = gateway_module_1.GatewayModule.getOptions();
+            expect(opts.config).toBe(sampleConfig);
+        });
+    });
+    describe('resolveConfig', () => {
+        it('should return direct config when provided', () => {
+            gateway_module_1.GatewayModule.forRoot({ config: sampleConfig });
+            const resolved = gateway_module_1.GatewayModule.resolveConfig();
+            expect(resolved).toBe(sampleConfig);
+            expect(resolved.routes).toHaveLength(2);
+        });
+        it('should read from configService when no direct config', () => {
+            gateway_module_1.GatewayModule.forRoot({ configKey: 'gateway' });
+            const mockConfigService = {
+                get: (key) => {
+                    if (key === 'gateway')
+                        return sampleConfig;
+                    return undefined;
+                },
+            };
+            const resolved = gateway_module_1.GatewayModule.resolveConfig(mockConfigService);
+            expect(resolved.routes).toHaveLength(2);
+            expect(resolved.routes[0].serviceName).toBe('user-service');
+        });
+        it('should throw when no config and no configService', () => {
+            gateway_module_1.GatewayModule.forRoot({ configKey: 'gateway' });
+            expect(() => gateway_module_1.GatewayModule.resolveConfig()).toThrow('No config provided');
+        });
+        it('should throw when configService returns undefined', () => {
+            gateway_module_1.GatewayModule.forRoot({ configKey: 'missing' });
+            const mockConfigService = {
+                get: (_key) => undefined,
+            };
+            expect(() => gateway_module_1.GatewayModule.resolveConfig(mockConfigService)).toThrow('No configuration found at key "missing"');
+        });
+        it('should throw when config has no routes array', () => {
+            gateway_module_1.GatewayModule.forRoot({ configKey: 'gateway' });
+            const mockConfigService = {
+                get: (key) => {
+                    if (key === 'gateway')
+                        return { discovery: {} };
+                    return undefined;
+                },
+            };
+            expect(() => gateway_module_1.GatewayModule.resolveConfig(mockConfigService)).toThrow('missing a "routes" array');
+        });
+    });
+});

package/dist/__tests__/gateway.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gateway.test.d.ts.map

package/dist/__tests__/gateway.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/gateway.test.ts"],"names":[],"mappings":""}