@hazeljs/discovery 0.2.0-alpha.1

package/dist/__tests__/consul-backend.test.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Consul Backend Tests
+ * Uses mocked Consul client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const consul_backend_1 = require("../backends/consul-backend");
+const types_1 = require("../types");
+const logger_1 = require("../utils/logger");
+// Suppress console logs during tests
+beforeAll(() => {
+    logger_1.DiscoveryLogger.setLogger({
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    });
+});
+afterAll(() => {
+    logger_1.DiscoveryLogger.resetLogger();
+});
+function createMockConsul() {
+    return {
+        agent: {
+            service: {
+                register: jest.fn().mockResolvedValue(undefined),
+                deregister: jest.fn().mockResolvedValue(undefined),
+                list: jest.fn().mockResolvedValue({}),
+            },
+            check: {
+                pass: jest.fn().mockResolvedValue(undefined),
+                fail: jest.fn().mockResolvedValue(undefined),
+                warn: jest.fn().mockResolvedValue(undefined),
+                list: jest.fn().mockResolvedValue({}),
+            },
+        },
+        health: {
+            service: jest.fn().mockResolvedValue([]),
+        },
+        catalog: {
+            service: {
+                list: jest.fn().mockResolvedValue({}),
+            },
+        },
+    };
+}
+function createInstance(id, name = 'test-service', overrides = {}) {
+    return {
+        id,
+        name,
+        host: 'localhost',
+        port: 3000,
+        status: types_1.ServiceStatus.UP,
+        lastHeartbeat: new Date('2025-01-01T00:00:00Z'),
+        registeredAt: new Date('2025-01-01T00:00:00Z'),
+        tags: ['web'],
+        metadata: { version: '1.0' },
+        zone: 'us-east-1',
+        ...overrides,
+    };
+}
+describe('ConsulRegistryBackend', () => {
+    let consul;
+    let backend;
+    beforeEach(() => {
+        jest.useFakeTimers();
+        consul = createMockConsul();
+        backend = new consul_backend_1.ConsulRegistryBackend(consul);
+    });
+    afterEach(async () => {
+        await backend.close();
+        jest.useRealTimers();
+    });
+    describe('constructor', () => {
+        it('should use default TTL of 30s', () => {
+            expect(backend).toBeDefined();
+        });
+        it('should accept custom config', () => {
+            const b = new consul_backend_1.ConsulRegistryBackend(consul, { ttl: '60s' });
+            expect(b).toBeDefined();
+        });
+        it('should throw on invalid TTL format', () => {
+            expect(() => {
+                new consul_backend_1.ConsulRegistryBackend(consul, { ttl: 'invalid' });
+            }).toThrow();
+        });
+    });
+    describe('register', () => {
+        it('should call consul agent service register', async () => {
+            const instance = createInstance('svc-1', 'my-service');
+            await backend.register(instance);
+            expect(consul.agent.service.register).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'svc-1',
+                name: 'my-service',
+                address: 'localhost',
+                port: 3000,
+            }));
+        });
+        it('should start TTL check interval', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            // Advance timers past the TTL check interval (2/3 of 30s = 20s)
+            jest.advanceTimersByTime(21000);
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+    });
+    describe('deregister', () => {
+        it('should call consul agent service deregister', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            await backend.deregister('svc-1');
+            expect(consul.agent.service.deregister).toHaveBeenCalledWith('svc-1');
+        });
+        it('should stop TTL check interval', async () => {
+            const instance = createInstance('svc-1');
+            await backend.register(instance);
+            await backend.deregister('svc-1');
+            jest.clearAllMocks();
+            jest.advanceTimersByTime(30000);
+            // TTL check should NOT have been called after deregister
+            expect(consul.agent.check.pass).not.toHaveBeenCalled();
+        });
+    });
+    describe('heartbeat', () => {
+        it('should pass the TTL check', async () => {
+            await backend.heartbeat('svc-1');
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should not throw when consul fails', async () => {
+            consul.agent.check.pass.mockRejectedValueOnce(new Error('Consul error'));
+            await expect(backend.heartbeat('svc-1')).resolves.not.toThrow();
+        });
+    });
+    describe('getInstances', () => {
+        it('should return instances from consul health service', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                        Meta: { zone: 'us-east-1', registeredAt: '2025-01-01T00:00:00Z' },
+                        Tags: ['web'],
+                    },
+                    Checks: [{ Status: 'passing' }],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                        Meta: { zone: 'us-west-1' },
+                        Tags: ['api'],
+                    },
+                    Checks: [{ Status: 'passing' }],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toHaveLength(2);
+            expect(instances[0].id).toBe('svc-1');
+            expect(instances[0].host).toBe('10.0.0.1');
+        });
+        it('should set status based on check results', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                    },
+                    Checks: [{ Status: 'critical' }],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                    },
+                    Checks: [{ Status: 'warning' }],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service');
+            expect(instances[0].status).toBe(types_1.ServiceStatus.DOWN);
+            expect(instances[1].status).toBe(types_1.ServiceStatus.STARTING);
+        });
+        it('should filter instances', async () => {
+            consul.health.service.mockResolvedValueOnce([
+                {
+                    Service: {
+                        ID: 'svc-1',
+                        Service: 'my-service',
+                        Address: '10.0.0.1',
+                        Port: 8080,
+                        Meta: { zone: 'us-east-1' },
+                    },
+                    Checks: [],
+                },
+                {
+                    Service: {
+                        ID: 'svc-2',
+                        Service: 'my-service',
+                        Address: '10.0.0.2',
+                        Port: 8080,
+                        Meta: { zone: 'us-west-1' },
+                    },
+                    Checks: [],
+                },
+            ]);
+            const instances = await backend.getInstances('my-service', { zone: 'us-east-1' });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].id).toBe('svc-1');
+        });
+        it('should return empty array on error', async () => {
+            consul.health.service.mockRejectedValueOnce(new Error('Consul error'));
+            const instances = await backend.getInstances('my-service');
+            expect(instances).toEqual([]);
+        });
+    });
+    describe('getInstance', () => {
+        it('should return a specific instance', async () => {
+            consul.agent.service.list.mockResolvedValueOnce({
+                'svc-1': {
+                    ID: 'svc-1',
+                    Service: 'my-service',
+                    Address: '10.0.0.1',
+                    Port: 8080,
+                    Meta: { zone: 'us-east-1' },
+                    Tags: ['web'],
+                },
+            });
+            consul.agent.check.list.mockResolvedValueOnce({
+                'service:svc-1': { Status: 'passing' },
+            });
+            const instance = await backend.getInstance('svc-1');
+            expect(instance).toBeDefined();
+            expect(instance.id).toBe('svc-1');
+            expect(instance.status).toBe(types_1.ServiceStatus.UP);
+        });
+        it('should return null for non-existent instance', async () => {
+            consul.agent.service.list.mockResolvedValueOnce({});
+            const instance = await backend.getInstance('non-existent');
+            expect(instance).toBeNull();
+        });
+        it('should return null on error', async () => {
+            consul.agent.service.list.mockRejectedValueOnce(new Error('fail'));
+            const instance = await backend.getInstance('svc-1');
+            expect(instance).toBeNull();
+        });
+    });
+    describe('getAllServices', () => {
+        it('should return service names from catalog', async () => {
+            consul.catalog.service.list.mockResolvedValueOnce({
+                'service-a': [],
+                'service-b': [],
+                consul: [],
+            });
+            const services = await backend.getAllServices();
+            expect(services).toEqual(['service-a', 'service-b', 'consul']);
+        });
+        it('should return empty array on error', async () => {
+            consul.catalog.service.list.mockRejectedValueOnce(new Error('fail'));
+            const services = await backend.getAllServices();
+            expect(services).toEqual([]);
+        });
+    });
+    describe('updateStatus', () => {
+        it('should pass check for UP status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.UP);
+            expect(consul.agent.check.pass).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should fail check for DOWN status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.DOWN);
+            expect(consul.agent.check.fail).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should warn check for STARTING status', async () => {
+            await backend.updateStatus('svc-1', types_1.ServiceStatus.STARTING);
+            expect(consul.agent.check.warn).toHaveBeenCalledWith('service:svc-1');
+        });
+        it('should not throw on error', async () => {
+            consul.agent.check.pass.mockRejectedValueOnce(new Error('fail'));
+            await expect(backend.updateStatus('svc-1', types_1.ServiceStatus.UP)).resolves.not.toThrow();
+        });
+    });
+    describe('close', () => {
+        it('should stop all TTL check intervals', async () => {
+            const i1 = createInstance('svc-1');
+            const i2 = createInstance('svc-2');
+            await backend.register(i1);
+            await backend.register(i2);
+            await backend.close();
+            jest.clearAllMocks();
+            jest.advanceTimersByTime(60000);
+            expect(consul.agent.check.pass).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Decorators Tests
+ */
+import 'reflect-metadata';
+//# sourceMappingURL=decorators.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/decorators.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/decorators.test.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Decorators Tests
+ */
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const service_registry_decorator_1 = require("../decorators/service-registry.decorator");
+const inject_service_client_decorator_1 = require("../decorators/inject-service-client.decorator");
+describe('Decorators', () => {
+    describe('ServiceRegistry', () => {
+        it('should attach metadata to class', () => {
+            const config = {
+                name: 'test-service',
+                port: 3000,
+                zone: 'us-east-1',
+            };
+            let TestService = class TestService {
+            };
+            TestService = __decorate([
+                (0, service_registry_decorator_1.ServiceRegistry)(config)
+            ], TestService);
+            const metadata = (0, service_registry_decorator_1.getServiceRegistryMetadata)(TestService);
+            expect(metadata).toEqual(config);
+        });
+        it('should return undefined for class without decorator', () => {
+            class TestService {
+            }
+            const metadata = (0, service_registry_decorator_1.getServiceRegistryMetadata)(TestService);
+            expect(metadata).toBeUndefined();
+        });
+    });
+    describe('InjectServiceClient', () => {
+        it('should attach metadata to parameter', () => {
+            let TestService = class TestService {
+                constructor(_userClient, _orderClient) { }
+            };
+            TestService = __decorate([
+                __param(0, (0, inject_service_client_decorator_1.InjectServiceClient)('user-service')),
+                __param(1, (0, inject_service_client_decorator_1.InjectServiceClient)('order-service', { timeout: 5000 })),
+                __metadata("design:paramtypes", [Object, Object])
+            ], TestService);
+            const metadata = (0, inject_service_client_decorator_1.getInjectServiceClientMetadata)(TestService);
+            expect(metadata).toBeDefined();
+            expect(metadata?.[0]).toEqual({
+                serviceName: 'user-service',
+            });
+            expect(metadata?.[1]).toEqual({
+                serviceName: 'order-service',
+                timeout: 5000,
+            });
+        });
+        it('should return undefined for class without decorator', () => {
+            class TestService {
+                constructor(_client) { }
+            }
+            const metadata = (0, inject_service_client_decorator_1.getInjectServiceClientMetadata)(TestService);
+            expect(metadata).toBeUndefined();
+        });
+    });
+});

package/dist/__tests__/discovery-client.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Discovery Client Tests
+ */
+export {};
+//# sourceMappingURL=discovery-client.test.d.ts.map

package/dist/__tests__/discovery-client.test.d.ts.map

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

package/dist/__tests__/discovery-client.test.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Discovery Client Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const discovery_client_1 = require("../client/discovery-client");
+const memory_backend_1 = require("../backends/memory-backend");
+const types_1 = require("../types");
+describe('DiscoveryClient', () => {
+    let client;
+    let backend;
+    beforeEach(() => {
+        backend = new memory_backend_1.MemoryRegistryBackend();
+        client = new discovery_client_1.DiscoveryClient({}, backend);
+    });
+    const createInstance = (id, name = 'test-service') => ({
+        id,
+        name,
+        host: 'localhost',
+        port: 3000,
+        status: types_1.ServiceStatus.UP,
+        lastHeartbeat: new Date(),
+        registeredAt: new Date(),
+    });
+    describe('getInstances', () => {
+        it('should return instances from backend', async () => {
+            const instance1 = createInstance('1', 'service-a');
+            const instance2 = createInstance('2', 'service-a');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const instances = await client.getInstances('service-a');
+            expect(instances).toHaveLength(2);
+        });
+        it('should apply filters', async () => {
+            const instance1 = { ...createInstance('1'), zone: 'us-east-1' };
+            const instance2 = { ...createInstance('2'), zone: 'us-west-1' };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const instances = await client.getInstances('test-service', {
+                zone: 'us-east-1',
+            });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].id).toBe('1');
+        });
+        it('should use cache when enabled', async () => {
+            const clientWithCache = new discovery_client_1.DiscoveryClient({ cacheEnabled: true, cacheTTL: 1000 }, backend);
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const first = await clientWithCache.getInstances('test-service');
+            expect(first).toHaveLength(1);
+            // Remove from backend
+            await backend.deregister('1');
+            // Should still return cached result
+            const second = await clientWithCache.getInstances('test-service');
+            expect(second).toHaveLength(1);
+        });
+        it('should refresh cache after TTL expires', async () => {
+            const clientWithCache = new discovery_client_1.DiscoveryClient({ cacheEnabled: true, cacheTTL: 50 }, backend);
+            const instance = createInstance('1');
+            await backend.register(instance);
+            await clientWithCache.getInstances('test-service');
+            await backend.deregister('1');
+            // Wait for cache to expire
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            const instances = await clientWithCache.getInstances('test-service');
+            expect(instances).toHaveLength(0);
+        });
+    });
+    describe('getInstance', () => {
+        it('should return a single instance using load balancing', async () => {
+            const instance1 = createInstance('1');
+            const instance2 = createInstance('2');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const instance = await client.getInstance('test-service');
+            expect(instance).toBeDefined();
+            expect(['1', '2']).toContain(instance?.id);
+        });
+        it('should return null when no instances available', async () => {
+            const instance = await client.getInstance('non-existent');
+            expect(instance).toBeNull();
+        });
+        it('should use specified load balancing strategy', async () => {
+            const instance1 = createInstance('1');
+            const instance2 = createInstance('2');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            // Round robin should cycle
+            const first = await client.getInstance('test-service', 'round-robin');
+            const second = await client.getInstance('test-service', 'round-robin');
+            const third = await client.getInstance('test-service', 'round-robin');
+            expect(first?.id).toBe('1');
+            expect(second?.id).toBe('2');
+            expect(third?.id).toBe('1');
+        });
+        it('should apply filters', async () => {
+            const instance1 = { ...createInstance('1'), zone: 'us-east-1' };
+            const instance2 = { ...createInstance('2'), zone: 'us-west-1' };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const instance = await client.getInstance('test-service', 'round-robin', {
+                zone: 'us-east-1',
+            });
+            expect(instance?.id).toBe('1');
+        });
+    });
+    describe('getAllServices', () => {
+        it('should return all service names', async () => {
+            await backend.register(createInstance('1', 'service-a'));
+            await backend.register(createInstance('2', 'service-b'));
+            const services = await client.getAllServices();
+            expect(services.sort()).toEqual(['service-a', 'service-b']);
+        });
+    });
+    describe('clearCache', () => {
+        it('should clear cache for specific service', () => {
+            const clientWithCache = new discovery_client_1.DiscoveryClient({ cacheEnabled: true }, backend);
+            clientWithCache.clearCache('service-a');
+            // Should not throw
+            expect(true).toBe(true);
+        });
+        it('should clear all cache when no service specified', () => {
+            const clientWithCache = new discovery_client_1.DiscoveryClient({ cacheEnabled: true }, backend);
+            clientWithCache.clearCache();
+            // Should not throw
+            expect(true).toBe(true);
+        });
+    });
+    describe('getBackend', () => {
+        it('should return the backend instance', () => {
+            const backend = client.getBackend();
+            expect(backend).toBeInstanceOf(memory_backend_1.MemoryRegistryBackend);
+        });
+    });
+    describe('getLoadBalancerFactory', () => {
+        it('should return the load balancer factory', () => {
+            const factory = client.getLoadBalancerFactory();
+            expect(factory).toBeDefined();
+            expect(factory.get('round-robin')).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/kubernetes-backend.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Kubernetes Backend Tests
+ * Uses mocked @kubernetes/client-node API
+ */
+export {};
+//# sourceMappingURL=kubernetes-backend.test.d.ts.map

package/dist/__tests__/kubernetes-backend.test.d.ts.map

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