@hazeljs/discovery 0.2.0-beta.1

package/dist/__tests__/load-balancer-strategies.test.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Load Balancer Strategies Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const strategies_1 = require("../load-balancer/strategies");
+const types_1 = require("../types");
+describe('Load Balancer Strategies', () => {
+    const createInstance = (id, status = types_1.ServiceStatus.UP) => ({
+        id,
+        name: 'test-service',
+        host: 'localhost',
+        port: 3000,
+        status,
+        lastHeartbeat: new Date(),
+        registeredAt: new Date(),
+    });
+    describe('RoundRobinStrategy', () => {
+        it('should cycle through instances in order', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            expect(strategy.choose(instances)?.id).toBe('1');
+            expect(strategy.choose(instances)?.id).toBe('2');
+            expect(strategy.choose(instances)?.id).toBe('3');
+            expect(strategy.choose(instances)?.id).toBe('1'); // Cycles back
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+        it('should filter out unhealthy instances', () => {
+            const strategy = new strategies_1.RoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.UP),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+                createInstance('3', types_1.ServiceStatus.UP),
+            ];
+            const first = strategy.choose(instances);
+            const second = strategy.choose(instances);
+            expect([first?.id, second?.id]).toEqual(['1', '3']);
+        });
+    });
+    describe('RandomStrategy', () => {
+        it('should return a random instance', () => {
+            const strategy = new strategies_1.RandomStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+            expect(['1', '2', '3']).toContain(selected?.id);
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.RandomStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('LeastConnectionsStrategy', () => {
+        it('should select instance with least connections', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('2');
+            const selected = strategy.choose(instances);
+            expect(selected?.id).toBe('3');
+        });
+        it('should handle connection increments and decrements', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1')];
+            strategy.incrementConnections('1');
+            strategy.incrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+            strategy.decrementConnections('1');
+            strategy.decrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+        });
+        it('should not allow negative connections', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [createInstance('1')];
+            strategy.decrementConnections('1');
+            strategy.decrementConnections('1');
+            expect(strategy.choose(instances)?.id).toBe('1');
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.LeastConnectionsStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('WeightedRoundRobinStrategy', () => {
+        it('should select instances based on weight', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                { ...createInstance('1'), metadata: { weight: 2 } },
+                { ...createInstance('2'), metadata: { weight: 1 } },
+            ];
+            const results = [];
+            for (let i = 0; i < 6; i++) {
+                const selected = strategy.choose(instances);
+                if (selected)
+                    results.push(selected.id);
+            }
+            // Should have more '1' than '2' due to weight
+            const count1 = results.filter((id) => id === '1').length;
+            const count2 = results.filter((id) => id === '2').length;
+            expect(count1).toBeGreaterThan(count2);
+        });
+        it('should default to weight 1 when weight is missing', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should handle invalid weight values', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                { ...createInstance('1'), metadata: { weight: 'invalid' } },
+                { ...createInstance('2'), metadata: { weight: -1 } },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.WeightedRoundRobinStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('IPHashStrategy', () => {
+        it('should return same instance for same IP', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [createInstance('1'), createInstance('2'), createInstance('3')];
+            const ip = '192.168.1.1';
+            const first = strategy.choose(instances, ip);
+            const second = strategy.choose(instances, ip);
+            expect(first?.id).toBe(second?.id);
+        });
+        it('should return first instance when no IP provided', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected?.id).toBe('1');
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.IPHashStrategy();
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances, '192.168.1.1')).toBeNull();
+        });
+    });
+    describe('ZoneAwareStrategy', () => {
+        it('should prefer instances in preferred zone', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                { ...createInstance('1'), zone: 'us-east-1' },
+                { ...createInstance('2'), zone: 'us-west-1' },
+                { ...createInstance('3'), zone: 'us-east-1' },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected?.zone).toBe('us-east-1');
+            expect(['1', '3']).toContain(selected?.id);
+        });
+        it('should fallback to any zone when preferred zone not available', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                { ...createInstance('1'), zone: 'us-west-1' },
+                { ...createInstance('2'), zone: 'eu-west-1' },
+            ];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+            expect(['1', '2']).toContain(selected?.id);
+        });
+        it('should work without preferred zone', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy();
+            const instances = [createInstance('1'), createInstance('2')];
+            const selected = strategy.choose(instances);
+            expect(selected).toBeDefined();
+        });
+        it('should return null when no healthy instances', () => {
+            const strategy = new strategies_1.ZoneAwareStrategy('us-east-1');
+            const instances = [
+                createInstance('1', types_1.ServiceStatus.DOWN),
+                createInstance('2', types_1.ServiceStatus.DOWN),
+            ];
+            expect(strategy.choose(instances)).toBeNull();
+        });
+    });
+    describe('LoadBalancerFactory', () => {
+        it('should register and retrieve strategies', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            const customStrategy = new strategies_1.RoundRobinStrategy();
+            customStrategy.name = 'custom';
+            factory.register(customStrategy);
+            expect(factory.get('custom')).toBe(customStrategy);
+        });
+        it('should create default strategies', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(factory.get('round-robin')).toBeDefined();
+            expect(factory.get('random')).toBeDefined();
+            expect(factory.get('least-connections')).toBeDefined();
+            expect(factory.get('weighted-round-robin')).toBeDefined();
+            expect(factory.get('ip-hash')).toBeDefined();
+        });
+        it('should create zone-aware strategy with options', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            const strategy = factory.create('zone-aware', { zone: 'us-east-1' });
+            expect(strategy).toBeInstanceOf(strategies_1.ZoneAwareStrategy);
+            expect(strategy.name).toBe('zone-aware');
+        });
+        it('should throw error for unknown strategy', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(() => factory.create('unknown-strategy')).toThrow("Load balancing strategy 'unknown-strategy' not found");
+        });
+        it('should return undefined for non-existent strategy', () => {
+            const factory = new strategies_1.LoadBalancerFactory();
+            expect(factory.get('non-existent')).toBeUndefined();
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Memory Backend Tests
+ */
+export {};
+//# sourceMappingURL=memory-backend.test.d.ts.map

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

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

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

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Memory Backend Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const memory_backend_1 = require("../backends/memory-backend");
+const types_1 = require("../types");
+describe('MemoryRegistryBackend', () => {
+    let backend;
+    beforeEach(() => {
+        backend = new memory_backend_1.MemoryRegistryBackend();
+    });
+    const createInstance = (id, name = 'test-service') => ({
+        id,
+        name,
+        host: 'localhost',
+        port: 3000,
+        status: types_1.ServiceStatus.UP,
+        lastHeartbeat: new Date(),
+        registeredAt: new Date(),
+    });
+    describe('register', () => {
+        it('should register a service instance', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toEqual(instance);
+        });
+        it('should index instances by service name', async () => {
+            const instance1 = createInstance('1', 'service-a');
+            const instance2 = createInstance('2', 'service-a');
+            const instance3 = createInstance('3', 'service-b');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instancesA = await backend.getInstances('service-a');
+            const instancesB = await backend.getInstances('service-b');
+            expect(instancesA).toHaveLength(2);
+            expect(instancesB).toHaveLength(1);
+        });
+    });
+    describe('deregister', () => {
+        it('should remove a registered instance', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            await backend.deregister('1');
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toBeNull();
+        });
+        it('should clean up service index when last instance is removed', async () => {
+            const instance = createInstance('1', 'service-a');
+            await backend.register(instance);
+            const servicesBefore = await backend.getAllServices();
+            expect(servicesBefore).toContain('service-a');
+            await backend.deregister('1');
+            const servicesAfter = await backend.getAllServices();
+            expect(servicesAfter).not.toContain('service-a');
+        });
+    });
+    describe('heartbeat', () => {
+        it('should update lastHeartbeat and set status to UP', async () => {
+            const instance = createInstance('1');
+            instance.status = types_1.ServiceStatus.DOWN;
+            await backend.register(instance);
+            const before = await backend.getInstance('1');
+            const beforeTime = before.lastHeartbeat.getTime();
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            await backend.heartbeat('1');
+            const after = await backend.getInstance('1');
+            expect(after.lastHeartbeat.getTime()).toBeGreaterThan(beforeTime);
+            expect(after.status).toBe(types_1.ServiceStatus.UP);
+        });
+    });
+    describe('getInstances', () => {
+        it('should return all instances for a service', async () => {
+            const instance1 = createInstance('1', 'service-a');
+            const instance2 = createInstance('2', 'service-a');
+            const instance3 = createInstance('3', 'service-b');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('service-a');
+            expect(instances).toHaveLength(2);
+            expect(instances.map((i) => i.id)).toEqual(['1', '2']);
+        });
+        it('should return empty array for non-existent service', async () => {
+            const instances = await backend.getInstances('non-existent');
+            expect(instances).toEqual([]);
+        });
+        it('should filter by zone', async () => {
+            const instance1 = { ...createInstance('1'), zone: 'us-east-1' };
+            const instance2 = { ...createInstance('2'), zone: 'us-west-1' };
+            const instance3 = { ...createInstance('3'), zone: 'us-east-1' };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('test-service', {
+                zone: 'us-east-1',
+            });
+            expect(instances).toHaveLength(2);
+            expect(instances.every((i) => i.zone === 'us-east-1')).toBe(true);
+        });
+        it('should filter by status', async () => {
+            const instance1 = { ...createInstance('1'), status: types_1.ServiceStatus.UP };
+            const instance2 = { ...createInstance('2'), status: types_1.ServiceStatus.DOWN };
+            const instance3 = { ...createInstance('3'), status: types_1.ServiceStatus.UP };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('test-service', {
+                status: types_1.ServiceStatus.UP,
+            });
+            expect(instances).toHaveLength(2);
+            expect(instances.every((i) => i.status === types_1.ServiceStatus.UP)).toBe(true);
+        });
+        it('should filter by tags', async () => {
+            const instance1 = { ...createInstance('1'), tags: ['web', 'api'] };
+            const instance2 = { ...createInstance('2'), tags: ['api'] };
+            const instance3 = { ...createInstance('3'), tags: ['web'] };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('test-service', {
+                tags: ['web', 'api'],
+            });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].id).toBe('1');
+        });
+        it('should filter by metadata', async () => {
+            const instance1 = {
+                ...createInstance('1'),
+                metadata: { version: '1.0.0', env: 'prod' },
+            };
+            const instance2 = {
+                ...createInstance('2'),
+                metadata: { version: '2.0.0', env: 'prod' },
+            };
+            const instance3 = {
+                ...createInstance('3'),
+                metadata: { version: '1.0.0', env: 'dev' },
+            };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('test-service', {
+                metadata: { version: '1.0.0' },
+            });
+            expect(instances).toHaveLength(2);
+            expect(instances.every((i) => i.metadata?.version === '1.0.0')).toBe(true);
+        });
+        it('should combine multiple filters', async () => {
+            const instance1 = {
+                ...createInstance('1'),
+                zone: 'us-east-1',
+                status: types_1.ServiceStatus.UP,
+                tags: ['web'],
+            };
+            const instance2 = {
+                ...createInstance('2'),
+                zone: 'us-east-1',
+                status: types_1.ServiceStatus.DOWN,
+                tags: ['web'],
+            };
+            const instance3 = {
+                ...createInstance('3'),
+                zone: 'us-west-1',
+                status: types_1.ServiceStatus.UP,
+                tags: ['web'],
+            };
+            await backend.register(instance1);
+            await backend.register(instance2);
+            await backend.register(instance3);
+            const instances = await backend.getInstances('test-service', {
+                zone: 'us-east-1',
+                status: types_1.ServiceStatus.UP,
+                tags: ['web'],
+            });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].id).toBe('1');
+        });
+    });
+    describe('getInstance', () => {
+        it('should return instance by ID', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toEqual(instance);
+        });
+        it('should return null for non-existent instance', async () => {
+            const retrieved = await backend.getInstance('non-existent');
+            expect(retrieved).toBeNull();
+        });
+    });
+    describe('getAllServices', () => {
+        it('should return all registered service names', async () => {
+            await backend.register(createInstance('1', 'service-a'));
+            await backend.register(createInstance('2', 'service-a'));
+            await backend.register(createInstance('3', 'service-b'));
+            const services = await backend.getAllServices();
+            expect(services.sort()).toEqual(['service-a', 'service-b']);
+        });
+        it('should return empty array when no services registered', async () => {
+            const services = await backend.getAllServices();
+            expect(services).toEqual([]);
+        });
+    });
+    describe('updateStatus', () => {
+        it('should update instance status', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            await backend.updateStatus('1', types_1.ServiceStatus.DOWN);
+            const updated = await backend.getInstance('1');
+            expect(updated.status).toBe(types_1.ServiceStatus.DOWN);
+            await backend.updateStatus('1', types_1.ServiceStatus.UP);
+            const updated2 = await backend.getInstance('1');
+            expect(updated2.status).toBe(types_1.ServiceStatus.UP);
+        });
+        it('should not throw error for non-existent instance', async () => {
+            await expect(backend.updateStatus('non-existent', types_1.ServiceStatus.DOWN)).resolves.not.toThrow();
+        });
+    });
+    describe('cleanup', () => {
+        it('should remove expired instances', async () => {
+            const backend = new memory_backend_1.MemoryRegistryBackend(100); // 100ms expiration
+            const instance = createInstance('1');
+            await backend.register(instance);
+            // Wait for expiration
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            await backend.cleanup();
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toBeNull();
+        });
+        it('should not remove active instances', async () => {
+            const backend = new memory_backend_1.MemoryRegistryBackend(100);
+            const instance = createInstance('1');
+            await backend.register(instance);
+            // Update heartbeat before expiration
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            await backend.heartbeat('1');
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            await backend.cleanup();
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toBeDefined();
+        });
+    });
+});

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

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

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

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