@hazeljs/discovery 0.2.0-alpha.1

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

@@ -0,0 +1,216 @@
+"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();
+            // retries: 3 → RetryPolicy maxAttempts: 3 → 1 initial + 3 retries = 4 total
+            expect(mockRequest).toHaveBeenCalledTimes(4);
+        });
+        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,115 @@
+/**
+ * Consul Registry Backend
+ * Integrates with HashiCorp Consul for service discovery
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+/**
+ * Minimal type definitions for the Consul client API surface we use.
+ * These mirror the shapes exposed by the `consul` npm package.
+ */
+export interface ConsulClient {
+    agent: {
+        service: {
+            register(opts: Record<string, unknown>): Promise<void>;
+            deregister(serviceId: string): Promise<void>;
+            list(): Promise<Record<string, ConsulServiceEntry>>;
+        };
+        check: {
+            pass(checkId: string): Promise<void>;
+            fail(checkId: string): Promise<void>;
+            warn(checkId: string): Promise<void>;
+            list(): Promise<Record<string, ConsulCheckEntry>>;
+        };
+    };
+    health: {
+        service(opts: {
+            service: string;
+            passing?: boolean;
+        }): Promise<ConsulHealthEntry[]>;
+    };
+    catalog: {
+        service: {
+            list(): Promise<Record<string, string[]>>;
+        };
+    };
+}
+export interface ConsulServiceEntry {
+    ID: string;
+    Service: string;
+    Address: string;
+    Port: number;
+    Meta?: Record<string, string>;
+    Tags?: string[];
+}
+export interface ConsulCheckEntry {
+    Status: string;
+}
+export interface ConsulHealthEntry {
+    Service: ConsulServiceEntry;
+    Checks?: ConsulCheckEntry[];
+}
+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: ConsulClient, 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;
+}
+//# 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;AAKzE;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE;QACL,OAAO,EAAE;YACP,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YACvD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YAC7C,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC;SACrD,CAAC;QACF,KAAK,EAAE;YACL,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;SACnD,CAAC;KACH,CAAC;IACF,MAAM,EAAE;QACN,OAAO,CAAC,IAAI,EAAE;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC;KACrF,CAAC;IACF,OAAO,EAAE;QACP,OAAO,EAAE;YACP,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;SAC3C,CAAC;KACH,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,kBAAkB,CAAC;IAC5B,MAAM,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,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,CAAe;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,cAAc,CAA0C;gBAEpD,MAAM,EAAE,YAAY,EAAE,MAAM,GAAE,mBAAwB;IAOlE;;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;IAYlD;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAgD3F;;OAEG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IA2CtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAYzC;;OAEG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBrE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAkBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAoBjB"}

package/dist/backends/consul-backend.js

@@ -0,0 +1,259 @@
+"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");
+const filter_1 = require("../utils/filter");
+const logger_1 = require("../utils/logger");
+const validation_1 = require("../utils/validation");
+class ConsulRegistryBackend {
+    constructor(consul, config = {}) {
+        this.checkIntervals = new Map();
+        (0, validation_1.validateConsulBackendConfig)(config);
+        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 logger = logger_1.DiscoveryLogger.getLogger();
+        const checkId = `service:${instanceId}`;
+        try {
+            // Pass TTL check
+            await this.consul.agent.check.pass(checkId);
+        }
+        catch (error) {
+            logger.warn(`Consul heartbeat failed for ${instanceId}, will retry on next heartbeat`, error);
+        }
+    }
+    /**
+     * Get all instances of a service
+     */
+    async getInstances(serviceName, filter) {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        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
+            return (0, filter_1.applyServiceFilter)(instances, filter);
+        }
+        catch (error) {
+            logger.error(`Failed to get instances for service "${serviceName}" from Consul`, error);
+            return [];
+        }
+    }
+    /**
+     * Get a specific service instance
+     */
+    async getInstance(instanceId) {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        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 (error) {
+            logger.error(`Failed to get instance "${instanceId}" from Consul`, error);
+            return null;
+        }
+    }
+    /**
+     * Get all registered services
+     */
+    async getAllServices() {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        try {
+            const services = await this.consul.catalog.service.list();
+            return Object.keys(services);
+        }
+        catch (error) {
+            logger.error('Failed to list services from Consul', error);
+            return [];
+        }
+    }
+    /**
+     * Update service instance status
+     */
+    async updateStatus(instanceId, status) {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        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 (error) {
+            logger.warn(`Failed to update status for ${instanceId} in Consul`, error);
+        }
+    }
+    /**
+     * 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) {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        // 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 (error) {
+                logger.warn(`TTL check pass failed for ${instanceId}`, error);
+            }
+        }, 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;
+        }
+    }
+}
+exports.ConsulRegistryBackend = ConsulRegistryBackend;