@hazeljs/discovery 0.2.0-beta.1

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

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Service Client Tests
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_client_1 = require("../client/service-client");
+const discovery_client_1 = require("../client/discovery-client");
+const memory_backend_1 = require("../backends/memory-backend");
+const types_1 = require("../types");
+const axios_1 = __importDefault(require("axios"));
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('ServiceClient', () => {
+    let serviceClient;
+    let discoveryClient;
+    let backend;
+    beforeEach(() => {
+        backend = new memory_backend_1.MemoryRegistryBackend();
+        discoveryClient = new discovery_client_1.DiscoveryClient({}, backend);
+        serviceClient = new service_client_1.ServiceClient(discoveryClient, {
+            serviceName: 'test-service',
+            timeout: 5000,
+            retries: 3,
+            retryDelay: 100,
+        });
+        // Reset mocks
+        jest.clearAllMocks();
+    });
+    const createInstance = (id) => ({
+        id,
+        name: 'test-service',
+        host: 'localhost',
+        port: 3000,
+        protocol: 'http',
+        status: types_1.ServiceStatus.UP,
+        lastHeartbeat: new Date(),
+        registeredAt: new Date(),
+    });
+    describe('GET requests', () => {
+        it('should make GET request to discovered service', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockResponse = { data: { message: 'success' }, status: 200 };
+            mockedAxios.create.mockReturnValue({
+                request: jest.fn().mockResolvedValue(mockResponse),
+            });
+            const client = new service_client_1.ServiceClient(discoveryClient, {
+                serviceName: 'test-service',
+            });
+            // Mock the axios instance request method
+            const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+            client.axiosInstance = { request: mockRequest };
+            await client.get('/api/users');
+            expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'GET',
+                url: '/api/users',
+            }));
+        });
+    });
+    describe('POST requests', () => {
+        it('should make POST request with data', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockResponse = { data: { id: 1 }, status: 201 };
+            const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.post('/api/users', { name: 'John' });
+            expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'POST',
+                url: '/api/users',
+                data: { name: 'John' },
+            }));
+        });
+    });
+    describe('PUT requests', () => {
+        it('should make PUT request with data', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockResponse = { data: { updated: true }, status: 200 };
+            const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.put('/api/users/1', { name: 'Jane' });
+            expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'PUT',
+                url: '/api/users/1',
+                data: { name: 'Jane' },
+            }));
+        });
+    });
+    describe('DELETE requests', () => {
+        it('should make DELETE request', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockResponse = { data: {}, status: 204 };
+            const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.delete('/api/users/1');
+            expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'DELETE',
+                url: '/api/users/1',
+            }));
+        });
+    });
+    describe('PATCH requests', () => {
+        it('should make PATCH request with data', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockResponse = { data: { patched: true }, status: 200 };
+            const mockRequest = jest.fn().mockResolvedValue(mockResponse);
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.patch('/api/users/1', { name: 'Updated' });
+            expect(mockRequest).toHaveBeenCalledWith(expect.objectContaining({
+                method: 'PATCH',
+                url: '/api/users/1',
+                data: { name: 'Updated' },
+            }));
+        });
+    });
+    describe('retry logic', () => {
+        it('should retry on failure', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockRequest = jest
+                .fn()
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockRejectedValueOnce(new Error('Network error'))
+                .mockResolvedValue({ data: { success: true }, status: 200 });
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.get('/api/users');
+            expect(mockRequest).toHaveBeenCalledTimes(3);
+        });
+        it('should throw error after max retries', async () => {
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockRequest = jest.fn().mockRejectedValue(new Error('Network error'));
+            serviceClient.axiosInstance = { request: mockRequest };
+            await expect(serviceClient.get('/api/users')).rejects.toThrow();
+            expect(mockRequest).toHaveBeenCalledTimes(3); // Default retries
+        });
+        it('should respect retry delay', async () => {
+            const client = new service_client_1.ServiceClient(discoveryClient, {
+                serviceName: 'test-service',
+                retries: 2,
+                retryDelay: 50,
+            });
+            const instance = createInstance('1');
+            await backend.register(instance);
+            const mockRequest = jest
+                .fn()
+                .mockRejectedValueOnce(new Error('Error 1'))
+                .mockResolvedValue({ data: {}, status: 200 });
+            client.axiosInstance = { request: mockRequest };
+            const start = Date.now();
+            await client.get('/api/users');
+            const duration = Date.now() - start;
+            // Should have waited at least 50ms for retry
+            expect(duration).toBeGreaterThanOrEqual(40); // Allow some margin
+        });
+    });
+    describe('service discovery integration', () => {
+        it('should use discovered service instance', async () => {
+            const instance1 = createInstance('1');
+            const instance2 = createInstance('2');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const mockRequest = jest.fn().mockResolvedValue({ data: {}, status: 200 });
+            serviceClient.axiosInstance = { request: mockRequest };
+            await serviceClient.get('/api/users');
+            // Should have used one of the instances
+            const call = mockRequest.mock.calls[0][0];
+            expect(call.baseURL).toMatch(/http:\/\/localhost:3000/);
+        });
+        it('should throw error when no instances available', async () => {
+            const mockRequest = jest.fn();
+            serviceClient.axiosInstance = { request: mockRequest };
+            await expect(serviceClient.get('/api/users')).rejects.toThrow('No instances available for service: test-service');
+        });
+    });
+    describe('load balancing strategy', () => {
+        it('should use specified load balancing strategy', async () => {
+            const instance1 = createInstance('1');
+            const instance2 = createInstance('2');
+            await backend.register(instance1);
+            await backend.register(instance2);
+            const client = new service_client_1.ServiceClient(discoveryClient, {
+                serviceName: 'test-service',
+                loadBalancingStrategy: 'random',
+            });
+            const mockRequest = jest.fn().mockResolvedValue({ data: {}, status: 200 });
+            client.axiosInstance = { request: mockRequest };
+            await client.get('/api/users');
+            expect(mockRequest).toHaveBeenCalled();
+        });
+    });
+    describe('filters', () => {
+        it('should apply service 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 client = new service_client_1.ServiceClient(discoveryClient, {
+                serviceName: 'test-service',
+                filter: { zone: 'us-east-1' },
+            });
+            const mockRequest = jest.fn().mockResolvedValue({ data: {}, status: 200 });
+            client.axiosInstance = { request: mockRequest };
+            await client.get('/api/users');
+            expect(mockRequest).toHaveBeenCalled();
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/service-registry.test.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Service Registry Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_registry_1 = require("../registry/service-registry");
+const memory_backend_1 = require("../backends/memory-backend");
+const types_1 = require("../types");
+describe('ServiceRegistry', () => {
+    let registry;
+    let backend;
+    beforeEach(() => {
+        backend = new memory_backend_1.MemoryRegistryBackend();
+        registry = new service_registry_1.ServiceRegistry({
+            name: 'test-service',
+            port: 3000,
+            host: 'localhost',
+            healthCheckPath: '/health',
+            metadata: { version: '1.0.0' },
+            zone: 'us-east-1',
+            tags: ['test'],
+        }, backend);
+    });
+    afterEach(async () => {
+        await registry.deregister();
+    });
+    describe('register', () => {
+        it('should register a service instance', async () => {
+            await registry.register();
+            const instance = registry.getInstance();
+            expect(instance).toBeDefined();
+            expect(instance?.name).toBe('test-service');
+            expect(instance?.port).toBe(3000);
+            expect(instance?.zone).toBe('us-east-1');
+        });
+        it('should set initial status to STARTING or DOWN after health check', async () => {
+            await registry.register();
+            const instance = registry.getInstance();
+            // Status will be STARTING initially, but health check runs immediately
+            // Since there's no actual server, it will become DOWN
+            expect([types_1.ServiceStatus.STARTING, types_1.ServiceStatus.DOWN]).toContain(instance?.status);
+        });
+    });
+    describe('deregister', () => {
+        it('should deregister a service instance', async () => {
+            await registry.register();
+            const instanceId = registry.getInstance()?.id;
+            await registry.deregister();
+            const instance = await backend.getInstance(instanceId);
+            expect(instance).toBeNull();
+        });
+    });
+    describe('getInstance', () => {
+        it('should return the registered instance', async () => {
+            await registry.register();
+            const instance = registry.getInstance();
+            expect(instance).toBeDefined();
+            expect(instance?.name).toBe('test-service');
+        });
+        it('should return null before registration', () => {
+            const instance = registry.getInstance();
+            expect(instance).toBeNull();
+        });
+    });
+});

package/dist/backends/consul-backend.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Consul Registry Backend
+ * Integrates with HashiCorp Consul for service discovery
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+type Consul = any;
+export interface ConsulBackendConfig {
+    host?: string;
+    port?: number;
+    secure?: boolean;
+    token?: string;
+    datacenter?: string;
+    ttl?: string;
+}
+export declare class ConsulRegistryBackend implements RegistryBackend {
+    private consul;
+    private readonly ttl;
+    private checkIntervals;
+    constructor(consul: Consul, config?: ConsulBackendConfig);
+    /**
+     * Register a service instance with Consul
+     */
+    register(instance: ServiceInstance): Promise<void>;
+    /**
+     * Deregister a service instance
+     */
+    deregister(instanceId: string): Promise<void>;
+    /**
+     * Update service instance heartbeat
+     */
+    heartbeat(instanceId: string): Promise<void>;
+    /**
+     * Get all instances of a service
+     */
+    getInstances(serviceName: string, filter?: ServiceFilter): Promise<ServiceInstance[]>;
+    /**
+     * Get a specific service instance
+     */
+    getInstance(instanceId: string): Promise<ServiceInstance | null>;
+    /**
+     * Get all registered services
+     */
+    getAllServices(): Promise<string[]>;
+    /**
+     * Update service instance status
+     */
+    updateStatus(instanceId: string, status: string): Promise<void>;
+    /**
+     * Clean up expired instances
+     * Consul handles this automatically via TTL checks
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Close Consul connection and stop all TTL checks
+     */
+    close(): Promise<void>;
+    /**
+     * Start TTL check updates for a service
+     */
+    private startTTLCheck;
+    /**
+     * Stop TTL check updates for a service
+     */
+    private stopTTLCheck;
+    /**
+     * Parse TTL string to seconds
+     */
+    private parseTTL;
+    /**
+     * Apply filter to instances
+     */
+    private applyFilter;
+}
+export {};
+//# sourceMappingURL=consul-backend.d.ts.map

package/dist/backends/consul-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consul-backend.d.ts","sourceRoot":"","sources":["../../src/backends/consul-backend.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAiB,MAAM,UAAU,CAAC;AAIzE,KAAK,MAAM,GAAG,GAAG,CAAC;AAElB,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,cAAc,CAA0C;gBAEpD,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,mBAAwB;IAK5D;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BxD;;OAEG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQnD;;OAEG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWlD;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA6D3F;;OAEG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAwCtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IASzC;;OAEG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAgBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAqBhB;;OAEG;IACH,OAAO,CAAC,WAAW;CA2BpB"}

package/dist/backends/consul-backend.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * Consul Registry Backend
+ * Integrates with HashiCorp Consul for service discovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsulRegistryBackend = void 0;
+const types_1 = require("../types");
+class ConsulRegistryBackend {
+    constructor(consul, config = {}) {
+        this.checkIntervals = new Map();
+        this.consul = consul;
+        this.ttl = config.ttl || '30s';
+    }
+    /**
+     * Register a service instance with Consul
+     */
+    async register(instance) {
+        const serviceId = instance.id;
+        const checkId = `service:${serviceId}`;
+        // Register service
+        await this.consul.agent.service.register({
+            id: serviceId,
+            name: instance.name,
+            address: instance.host,
+            port: instance.port,
+            tags: instance.tags || [],
+            meta: {
+                ...instance.metadata,
+                zone: instance.zone || '',
+                registeredAt: instance.registeredAt.toISOString(),
+            },
+            check: {
+                ttl: this.ttl,
+                deregister_critical_service_after: '90s',
+            },
+        });
+        // Start TTL check updates
+        this.startTTLCheck(serviceId, checkId);
+    }
+    /**
+     * Deregister a service instance
+     */
+    async deregister(instanceId) {
+        // Stop TTL check
+        this.stopTTLCheck(instanceId);
+        // Deregister from Consul
+        await this.consul.agent.service.deregister(instanceId);
+    }
+    /**
+     * Update service instance heartbeat
+     */
+    async heartbeat(instanceId) {
+        const checkId = `service:${instanceId}`;
+        try {
+            // Pass TTL check
+            await this.consul.agent.check.pass(checkId);
+        }
+        catch {
+            // Silently fail - will be retried on next heartbeat
+        }
+    }
+    /**
+     * Get all instances of a service
+     */
+    async getInstances(serviceName, filter) {
+        try {
+            const result = await this.consul.health.service({
+                service: serviceName,
+                passing: filter?.status === types_1.ServiceStatus.UP,
+            });
+            const instances = result.map((entry) => {
+                const service = entry.Service;
+                const checks = entry.Checks || [];
+                // Determine status from checks
+                let status = types_1.ServiceStatus.UP;
+                for (const check of checks) {
+                    if (check.Status === 'critical') {
+                        status = types_1.ServiceStatus.DOWN;
+                        break;
+                    }
+                    else if (check.Status === 'warning') {
+                        status = types_1.ServiceStatus.STARTING;
+                    }
+                }
+                return {
+                    id: service.ID,
+                    name: service.Service,
+                    host: service.Address,
+                    port: service.Port,
+                    status,
+                    metadata: service.Meta || {},
+                    tags: service.Tags || [],
+                    zone: service.Meta?.zone || undefined,
+                    lastHeartbeat: new Date(),
+                    registeredAt: service.Meta?.registeredAt
+                        ? new Date(service.Meta.registeredAt)
+                        : new Date(),
+                };
+            });
+            // Apply additional filters
+            if (filter) {
+                return this.applyFilter(instances, filter);
+            }
+            return instances;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get a specific service instance
+     */
+    async getInstance(instanceId) {
+        try {
+            const services = await this.consul.agent.service.list();
+            const service = services[instanceId];
+            if (!service) {
+                return null;
+            }
+            // Get health status
+            const checks = await this.consul.agent.check.list();
+            const checkId = `service:${instanceId}`;
+            const check = checks[checkId];
+            let status = types_1.ServiceStatus.UP;
+            if (check) {
+                if (check.Status === 'critical') {
+                    status = types_1.ServiceStatus.DOWN;
+                }
+                else if (check.Status === 'warning') {
+                    status = types_1.ServiceStatus.STARTING;
+                }
+            }
+            return {
+                id: service.ID,
+                name: service.Service,
+                host: service.Address,
+                port: service.Port,
+                status,
+                metadata: service.Meta || {},
+                tags: service.Tags || [],
+                zone: service.Meta?.zone || undefined,
+                lastHeartbeat: new Date(),
+                registeredAt: service.Meta?.registeredAt ? new Date(service.Meta.registeredAt) : new Date(),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get all registered services
+     */
+    async getAllServices() {
+        try {
+            const services = await this.consul.catalog.service.list();
+            return Object.keys(services);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Update service instance status
+     */
+    async updateStatus(instanceId, status) {
+        const checkId = `service:${instanceId}`;
+        try {
+            if (status === types_1.ServiceStatus.UP) {
+                await this.consul.agent.check.pass(checkId);
+            }
+            else if (status === types_1.ServiceStatus.DOWN) {
+                await this.consul.agent.check.fail(checkId);
+            }
+            else if (status === types_1.ServiceStatus.STARTING) {
+                await this.consul.agent.check.warn(checkId);
+            }
+        }
+        catch {
+            // Silently fail - status will be updated on next heartbeat
+        }
+    }
+    /**
+     * Clean up expired instances
+     * Consul handles this automatically via TTL checks
+     */
+    async cleanup() {
+        // Consul automatically deregisters services that fail TTL checks
+        // No manual cleanup needed
+    }
+    /**
+     * Close Consul connection and stop all TTL checks
+     */
+    async close() {
+        // Stop all TTL check intervals
+        for (const [instanceId] of this.checkIntervals) {
+            this.stopTTLCheck(instanceId);
+        }
+    }
+    /**
+     * Start TTL check updates for a service
+     */
+    startTTLCheck(instanceId, checkId) {
+        // Parse TTL to get interval (update at 2/3 of TTL)
+        const ttlSeconds = this.parseTTL(this.ttl);
+        const intervalMs = (ttlSeconds * 1000 * 2) / 3;
+        const interval = setInterval(async () => {
+            try {
+                await this.consul.agent.check.pass(checkId);
+            }
+            catch {
+                // Silently fail - will be retried on next interval
+            }
+        }, intervalMs);
+        this.checkIntervals.set(instanceId, interval);
+    }
+    /**
+     * Stop TTL check updates for a service
+     */
+    stopTTLCheck(instanceId) {
+        const interval = this.checkIntervals.get(instanceId);
+        if (interval) {
+            clearInterval(interval);
+            this.checkIntervals.delete(instanceId);
+        }
+    }
+    /**
+     * Parse TTL string to seconds
+     */
+    parseTTL(ttl) {
+        const match = ttl.match(/^(\d+)([smh])$/);
+        if (!match) {
+            return 30; // default 30 seconds
+        }
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        switch (unit) {
+            case 's':
+                return value;
+            case 'm':
+                return value * 60;
+            case 'h':
+                return value * 3600;
+            default:
+                return 30;
+        }
+    }
+    /**
+     * Apply filter to instances
+     */
+    applyFilter(instances, filter) {
+        return instances.filter((instance) => {
+            if (filter.zone && instance.zone !== filter.zone) {
+                return false;
+            }
+            if (filter.status && instance.status !== filter.status) {
+                return false;
+            }
+            if (filter.tags && filter.tags.length > 0) {
+                if (!instance.tags || !filter.tags.every((tag) => instance.tags.includes(tag))) {
+                    return false;
+                }
+            }
+            if (filter.metadata) {
+                for (const [key, value] of Object.entries(filter.metadata)) {
+                    if (!instance.metadata || instance.metadata[key] !== value) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.ConsulRegistryBackend = ConsulRegistryBackend;