@hazeljs/discovery 0.2.0-alpha.1

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__/redis-backend.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redis Backend Tests
+ * Uses mocked ioredis client
+ */
+export {};
+//# sourceMappingURL=redis-backend.test.d.ts.map

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

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

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

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * Redis Backend Tests
+ * Uses mocked ioredis client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_backend_1 = require("../backends/redis-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();
+});
+/** Helper to create a mock Redis instance */
+function createMockRedis() {
+    const store = new Map();
+    const sets = new Map();
+    const ttls = new Map();
+    const listeners = new Map();
+    const mock = {
+        on: jest.fn((event, handler) => {
+            if (!listeners.has(event))
+                listeners.set(event, []);
+            listeners.get(event).push(handler);
+        }),
+        setex: jest.fn(async (key, ttl, value) => {
+            store.set(key, value);
+            ttls.set(key, ttl);
+        }),
+        get: jest.fn(async (key) => store.get(key) || null),
+        del: jest.fn(async (key) => {
+            store.delete(key);
+            ttls.delete(key);
+            return 1;
+        }),
+        mget: jest.fn(async (...keys) => {
+            // mget can receive keys as individual args or a single array
+            const flatKeys = keys.flat();
+            return flatKeys.map((k) => store.get(k) || null);
+        }),
+        sadd: jest.fn(async (key, member) => {
+            if (!sets.has(key))
+                sets.set(key, new Set());
+            sets.get(key).add(member);
+            return 1;
+        }),
+        srem: jest.fn(async (key, member) => {
+            sets.get(key)?.delete(member);
+            return 1;
+        }),
+        smembers: jest.fn(async (key) => {
+            return Array.from(sets.get(key) || []);
+        }),
+        scard: jest.fn(async (key) => {
+            return sets.get(key)?.size || 0;
+        }),
+        exists: jest.fn(async (key) => {
+            return store.has(key) ? 1 : 0;
+        }),
+        expire: jest.fn(async () => 1),
+        scan: jest.fn(async (_cursor, _match, pattern) => {
+            const keys = Array.from(sets.keys()).filter((k) => {
+                // Simple glob match: convert "prefix*" to regex
+                const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+                return regex.test(k);
+            });
+            return ['0', keys];
+        }),
+        quit: jest.fn(async () => 'OK'),
+        // Helper to emit events during tests
+        _emit: (event, ...args) => {
+            const handlers = listeners.get(event) || [];
+            handlers.forEach((h) => h(...args));
+        },
+    };
+    return mock;
+}
+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'),
+        ...overrides,
+    };
+}
+describe('RedisRegistryBackend', () => {
+    let redis;
+    let backend;
+    beforeEach(() => {
+        redis = createMockRedis();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        backend = new redis_backend_1.RedisRegistryBackend(redis);
+    });
+    describe('constructor', () => {
+        it('should use default config values', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const b = new redis_backend_1.RedisRegistryBackend(redis);
+            expect(b).toBeDefined();
+        });
+        it('should accept custom config', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const b = new redis_backend_1.RedisRegistryBackend(redis, {
+                keyPrefix: 'custom:',
+                ttl: 120,
+            });
+            expect(b).toBeDefined();
+        });
+        it('should throw on invalid TTL', () => {
+            expect(() => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                new redis_backend_1.RedisRegistryBackend(redis, { ttl: -5 });
+            }).toThrow();
+        });
+        it('should register connection event handlers', () => {
+            expect(redis.on).toHaveBeenCalledWith('error', expect.any(Function));
+            expect(redis.on).toHaveBeenCalledWith('connect', expect.any(Function));
+            expect(redis.on).toHaveBeenCalledWith('reconnecting', expect.any(Function));
+            expect(redis.on).toHaveBeenCalledWith('close', expect.any(Function));
+        });
+    });
+    describe('register', () => {
+        it('should store the instance with TTL', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            expect(redis.setex).toHaveBeenCalledWith('hazeljs:discovery:instance:1', 90, JSON.stringify(instance));
+        });
+        it('should add instance to service set', async () => {
+            const instance = createInstance('1', 'my-service');
+            await backend.register(instance);
+            expect(redis.sadd).toHaveBeenCalledWith('hazeljs:discovery:service:my-service', '1');
+        });
+        it('should set expiration on service set', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            expect(redis.expire).toHaveBeenCalledWith('hazeljs:discovery:service:test-service', 180);
+        });
+    });
+    describe('deregister', () => {
+        it('should remove instance from Redis', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            await backend.deregister('1');
+            expect(redis.srem).toHaveBeenCalledWith('hazeljs:discovery:service:test-service', '1');
+            expect(redis.del).toHaveBeenCalledWith('hazeljs:discovery:instance:1');
+        });
+        it('should do nothing if instance does not exist', async () => {
+            await backend.deregister('non-existent');
+            expect(redis.del).not.toHaveBeenCalled();
+        });
+    });
+    describe('heartbeat', () => {
+        it('should update heartbeat timestamp and status', async () => {
+            const instance = createInstance('1');
+            instance.status = types_1.ServiceStatus.DOWN;
+            await backend.register(instance);
+            await backend.heartbeat('1');
+            // Should have been called again with updated data
+            expect(redis.setex).toHaveBeenCalledTimes(2);
+            const lastCall = redis.setex.mock.calls[1];
+            const storedInstance = JSON.parse(lastCall[2]);
+            expect(storedInstance.status).toBe(types_1.ServiceStatus.UP);
+        });
+        it('should do nothing if instance does not exist', async () => {
+            await backend.heartbeat('non-existent');
+            // setex should not be called
+            expect(redis.setex).not.toHaveBeenCalled();
+        });
+    });
+    describe('getInstances', () => {
+        it('should return all instances for a service using MGET', async () => {
+            const i1 = createInstance('1', 'svc');
+            const i2 = createInstance('2', 'svc');
+            await backend.register(i1);
+            await backend.register(i2);
+            const instances = await backend.getInstances('svc');
+            expect(instances).toHaveLength(2);
+            expect(redis.mget).toHaveBeenCalled();
+        });
+        it('should return empty array for non-existent service', async () => {
+            const instances = await backend.getInstances('non-existent');
+            expect(instances).toEqual([]);
+        });
+        it('should apply filter', async () => {
+            const i1 = createInstance('1', 'svc', { zone: 'us-east-1' });
+            const i2 = createInstance('2', 'svc', { zone: 'us-west-1' });
+            await backend.register(i1);
+            await backend.register(i2);
+            const instances = await backend.getInstances('svc', { zone: 'us-east-1' });
+            expect(instances).toHaveLength(1);
+            expect(instances[0].zone).toBe('us-east-1');
+        });
+    });
+    describe('getInstance', () => {
+        it('should return a specific instance', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved).toBeDefined();
+            expect(retrieved.id).toBe('1');
+        });
+        it('should return null for non-existent instance', async () => {
+            const result = await backend.getInstance('non-existent');
+            expect(result).toBeNull();
+        });
+        it('should convert dates back from strings', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved.lastHeartbeat).toBeInstanceOf(Date);
+            expect(retrieved.registeredAt).toBeInstanceOf(Date);
+        });
+    });
+    describe('getAllServices', () => {
+        it('should use SCAN instead of KEYS', async () => {
+            const i1 = createInstance('1', 'svc-a');
+            const i2 = createInstance('2', 'svc-b');
+            await backend.register(i1);
+            await backend.register(i2);
+            const services = await backend.getAllServices();
+            expect(redis.scan).toHaveBeenCalled();
+            expect(services).toHaveLength(2);
+        });
+    });
+    describe('updateStatus', () => {
+        it('should update the status of an instance', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            await backend.updateStatus('1', types_1.ServiceStatus.DOWN);
+            const retrieved = await backend.getInstance('1');
+            expect(retrieved.status).toBe(types_1.ServiceStatus.DOWN);
+        });
+        it('should do nothing for non-existent instance', async () => {
+            await backend.updateStatus('non-existent', types_1.ServiceStatus.DOWN);
+            expect(redis.setex).not.toHaveBeenCalled();
+        });
+    });
+    describe('cleanup', () => {
+        it('should remove stale entries from service sets', async () => {
+            const instance = createInstance('1', 'svc');
+            await backend.register(instance);
+            // Simulate the instance key expiring in Redis
+            redis.exists.mockResolvedValueOnce(0);
+            await backend.cleanup();
+            expect(redis.srem).toHaveBeenCalledWith('hazeljs:discovery:service:svc', '1');
+        });
+    });
+    describe('connection error handling', () => {
+        it('should track connection state via events', () => {
+            redis._emit('close');
+            // Backend should mark as disconnected
+            // Next operation should throw
+            expect(backend.getInstances('svc')).rejects.toThrow('Redis backend is not connected');
+        });
+        it('should recover on connect event', async () => {
+            redis._emit('close');
+            redis._emit('connect');
+            // Should work again
+            const result = await backend.getInstances('svc');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('close', () => {
+        it('should call redis.quit()', async () => {
+            await backend.close();
+            expect(redis.quit).toHaveBeenCalled();
+        });
+    });
+});

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"}