@hazeljs/discovery 0.2.0-beta.1

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

@@ -0,0 +1,65 @@
+/**
+ * Kubernetes Registry Backend
+ * Uses Kubernetes Service Discovery
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+type KubeConfig = any;
+export interface KubernetesBackendConfig {
+    namespace?: string;
+    labelSelector?: string;
+}
+export declare class KubernetesRegistryBackend implements RegistryBackend {
+    private k8sApi;
+    private readonly namespace;
+    private readonly labelSelector;
+    constructor(kubeConfig: KubeConfig, config?: KubernetesBackendConfig);
+    /**
+     * Register a service instance
+     * In Kubernetes, services are registered via Service/Endpoints objects
+     * This is typically handled by K8s itself
+     */
+    register(_instance: ServiceInstance): Promise<void>;
+    /**
+     * Deregister a service instance
+     * In Kubernetes, this is handled automatically when pods terminate
+     */
+    deregister(_instanceId: string): Promise<void>;
+    /**
+     * Update service instance heartbeat
+     * Kubernetes handles liveness/readiness probes
+     */
+    heartbeat(_instanceId: string): Promise<void>;
+    /**
+     * Get all instances of a service from Kubernetes Endpoints
+     */
+    getInstances(serviceName: string, filter?: ServiceFilter): Promise<ServiceInstance[]>;
+    /**
+     * Get a specific service instance
+     */
+    getInstance(instanceId: string): Promise<ServiceInstance | null>;
+    /**
+     * Get all registered services in the namespace
+     */
+    getAllServices(): Promise<string[]>;
+    /**
+     * Update service instance status
+     * In Kubernetes, status is managed by readiness probes
+     */
+    updateStatus(_instanceId: string, _status: string): Promise<void>;
+    /**
+     * Clean up expired instances
+     * Kubernetes handles this automatically
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Create a ServiceInstance from Kubernetes endpoint data
+     */
+    private createServiceInstance;
+    /**
+     * Apply filter to instances
+     */
+    private applyFilter;
+}
+export {};
+//# sourceMappingURL=kubernetes-backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kubernetes-backend.d.ts","sourceRoot":"","sources":["../../src/backends/kubernetes-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,UAAU,GAAG,GAAG,CAAC;AAItB,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,yBAA0B,YAAW,eAAe;IAC/D,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,UAAU,EAAE,UAAU,EAAE,MAAM,GAAE,uBAA4B;IASxE;;;;OAIG;IACG,QAAQ,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzD;;;OAGG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIpD;;;OAGG;IACG,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD;;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;IAQtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAmBzC;;;OAGG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsC7B;;OAEG;IACH,OAAO,CAAC,WAAW;CA2BpB"}

package/dist/backends/kubernetes-backend.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Kubernetes Registry Backend
+ * Uses Kubernetes Service Discovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KubernetesRegistryBackend = void 0;
+const types_1 = require("../types");
+class KubernetesRegistryBackend {
+    constructor(kubeConfig, config = {}) {
+        // Import CoreV1Api dynamically to avoid build errors when @kubernetes/client-node is not installed
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { CoreV1Api: CoreV1ApiClass } = require('@kubernetes/client-node');
+        this.k8sApi = kubeConfig.makeApiClient(CoreV1ApiClass);
+        this.namespace = config.namespace || 'default';
+        this.labelSelector = config.labelSelector || 'app.kubernetes.io/managed-by=hazeljs';
+    }
+    /**
+     * Register a service instance
+     * In Kubernetes, services are registered via Service/Endpoints objects
+     * This is typically handled by K8s itself
+     */
+    async register(_instance) {
+        // In Kubernetes, service registration is handled by the platform
+        // We can optionally create/update annotations on the pod
+        // Service registration is managed by Kubernetes
+    }
+    /**
+     * Deregister a service instance
+     * In Kubernetes, this is handled automatically when pods terminate
+     */
+    async deregister(_instanceId) {
+        // Service deregistration is managed by Kubernetes
+    }
+    /**
+     * Update service instance heartbeat
+     * Kubernetes handles liveness/readiness probes
+     */
+    async heartbeat(_instanceId) {
+        // Kubernetes handles health checks via probes
+        // No manual heartbeat needed
+    }
+    /**
+     * Get all instances of a service from Kubernetes Endpoints
+     */
+    async getInstances(serviceName, filter) {
+        try {
+            // Get service endpoints
+            const endpointsResponse = await this.k8sApi.readNamespacedEndpoints(serviceName, this.namespace);
+            const endpoints = endpointsResponse.body;
+            const instances = [];
+            if (!endpoints.subsets) {
+                return [];
+            }
+            // Process each subset
+            for (const subset of endpoints.subsets) {
+                const ports = subset.ports || [];
+                const addresses = subset.addresses || [];
+                const notReadyAddresses = subset.notReadyAddresses || [];
+                // Process ready addresses
+                for (const address of addresses) {
+                    for (const port of ports) {
+                        const instance = this.createServiceInstance(serviceName, address, port, types_1.ServiceStatus.UP, endpoints.metadata);
+                        instances.push(instance);
+                    }
+                }
+                // Process not-ready addresses
+                for (const address of notReadyAddresses) {
+                    for (const port of ports) {
+                        const instance = this.createServiceInstance(serviceName, address, port, types_1.ServiceStatus.STARTING, endpoints.metadata);
+                        instances.push(instance);
+                    }
+                }
+            }
+            // Apply filters
+            if (filter) {
+                return this.applyFilter(instances, filter);
+            }
+            return instances;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get a specific service instance
+     */
+    async getInstance(instanceId) {
+        // Parse instanceId to get service name and address
+        const [serviceName] = instanceId.split(':');
+        const instances = await this.getInstances(serviceName);
+        return instances.find((i) => i.id === instanceId) || null;
+    }
+    /**
+     * Get all registered services in the namespace
+     */
+    async getAllServices() {
+        try {
+            const servicesResponse = await this.k8sApi.listNamespacedService(this.namespace, undefined, undefined, undefined, undefined, this.labelSelector);
+            return servicesResponse.body.items.map((service) => service.metadata?.name || '');
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Update service instance status
+     * In Kubernetes, status is managed by readiness probes
+     */
+    async updateStatus(_instanceId, _status) {
+        // Kubernetes manages status via probes
+    }
+    /**
+     * Clean up expired instances
+     * Kubernetes handles this automatically
+     */
+    async cleanup() {
+        // Kubernetes automatically removes terminated pods
+    }
+    /**
+     * Create a ServiceInstance from Kubernetes endpoint data
+     */
+    createServiceInstance(serviceName, address, port, status, metadata) {
+        const host = address.ip;
+        const portNumber = port.port;
+        const instanceId = `${serviceName}:${host}:${portNumber}`;
+        // Extract metadata from annotations and labels
+        const annotations = metadata?.annotations || {};
+        const labels = metadata?.labels || {};
+        return {
+            id: instanceId,
+            name: serviceName,
+            host,
+            port: portNumber,
+            status,
+            metadata: {
+                ...annotations,
+                podName: address.targetRef?.name,
+                nodeName: address.nodeName,
+            },
+            tags: Object.keys(labels),
+            zone: labels['topology.kubernetes.io/zone'] || labels['failure-domain.beta.kubernetes.io/zone'],
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(metadata?.creationTimestamp || Date.now()),
+        };
+    }
+    /**
+     * 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.KubernetesRegistryBackend = KubernetesRegistryBackend;

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

@@ -0,0 +1,22 @@
+/**
+ * In-Memory Registry Backend
+ * For development and testing
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+export declare class MemoryRegistryBackend implements RegistryBackend {
+    private instances;
+    private serviceIndex;
+    private readonly expirationTime;
+    constructor(expirationTime?: number);
+    register(instance: ServiceInstance): Promise<void>;
+    deregister(instanceId: string): Promise<void>;
+    heartbeat(instanceId: string): Promise<void>;
+    getInstances(serviceName: string, filter?: ServiceFilter): Promise<ServiceInstance[]>;
+    getInstance(instanceId: string): Promise<ServiceInstance | null>;
+    getAllServices(): Promise<string[]>;
+    updateStatus(instanceId: string, status: string): Promise<void>;
+    cleanup(): Promise<void>;
+    private applyFilter;
+}
+//# sourceMappingURL=memory-backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-backend.d.ts","sourceRoot":"","sources":["../../src/backends/memory-backend.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAiB,MAAM,UAAU,CAAC;AAEzE,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,SAAS,CAAsC;IACvD,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,cAAc,SAAQ;IAK5B,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlD,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB7C,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5C,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAoBrF,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAIhE,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAInC,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB9B,OAAO,CAAC,WAAW;CA+BpB"}

package/dist/backends/memory-backend.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * In-Memory Registry Backend
+ * For development and testing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRegistryBackend = void 0;
+const types_1 = require("../types");
+class MemoryRegistryBackend {
+    constructor(expirationTime = 90000) {
+        this.instances = new Map();
+        this.serviceIndex = new Map();
+        // 90 seconds default
+        this.expirationTime = expirationTime;
+    }
+    async register(instance) {
+        this.instances.set(instance.id, instance);
+        // Update service index
+        if (!this.serviceIndex.has(instance.name)) {
+            this.serviceIndex.set(instance.name, new Set());
+        }
+        this.serviceIndex.get(instance.name).add(instance.id);
+    }
+    async deregister(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (instance) {
+            this.instances.delete(instanceId);
+            // Update service index
+            const serviceInstances = this.serviceIndex.get(instance.name);
+            if (serviceInstances) {
+                serviceInstances.delete(instanceId);
+                if (serviceInstances.size === 0) {
+                    this.serviceIndex.delete(instance.name);
+                }
+            }
+        }
+    }
+    async heartbeat(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (instance) {
+            instance.lastHeartbeat = new Date();
+            instance.status = types_1.ServiceStatus.UP;
+        }
+    }
+    async getInstances(serviceName, filter) {
+        const instanceIds = this.serviceIndex.get(serviceName);
+        if (!instanceIds)
+            return [];
+        let instances = [];
+        for (const id of instanceIds) {
+            const instance = this.instances.get(id);
+            if (instance) {
+                instances.push(instance);
+            }
+        }
+        // Apply filters
+        if (filter) {
+            instances = this.applyFilter(instances, filter);
+        }
+        return instances;
+    }
+    async getInstance(instanceId) {
+        return this.instances.get(instanceId) || null;
+    }
+    async getAllServices() {
+        return Array.from(this.serviceIndex.keys());
+    }
+    async updateStatus(instanceId, status) {
+        const instance = this.instances.get(instanceId);
+        if (instance) {
+            instance.status = status;
+        }
+    }
+    async cleanup() {
+        const now = Date.now();
+        const expiredIds = [];
+        for (const [id, instance] of this.instances) {
+            const timeSinceHeartbeat = now - instance.lastHeartbeat.getTime();
+            if (timeSinceHeartbeat > this.expirationTime) {
+                expiredIds.push(id);
+            }
+        }
+        for (const id of expiredIds) {
+            await this.deregister(id);
+        }
+    }
+    applyFilter(instances, filter) {
+        return instances.filter((instance) => {
+            // Filter by zone
+            if (filter.zone && instance.zone !== filter.zone) {
+                return false;
+            }
+            // Filter by status
+            if (filter.status && instance.status !== filter.status) {
+                return false;
+            }
+            // Filter by tags
+            if (filter.tags && filter.tags.length > 0) {
+                if (!instance.tags || !filter.tags.every((tag) => instance.tags.includes(tag))) {
+                    return false;
+                }
+            }
+            // Filter by metadata
+            if (filter.metadata) {
+                for (const [key, value] of Object.entries(filter.metadata)) {
+                    if (!instance.metadata || instance.metadata[key] !== value) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.MemoryRegistryBackend = MemoryRegistryBackend;

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

@@ -0,0 +1,71 @@
+/**
+ * Redis Registry Backend
+ * For production distributed service registry
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+import type { Redis } from 'ioredis';
+export interface RedisBackendConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    ttl?: number;
+}
+export declare class RedisRegistryBackend implements RegistryBackend {
+    private redis;
+    private readonly keyPrefix;
+    private readonly ttl;
+    constructor(redis: Redis, config?: RedisBackendConfig);
+    /**
+     * Register a service instance
+     */
+    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
+     * Note: Redis handles expiration automatically via TTL
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Close Redis connection
+     */
+    close(): Promise<void>;
+    /**
+     * Get Redis key for instance
+     */
+    private getInstanceKey;
+    /**
+     * Get Redis key for service set
+     */
+    private getServiceSetKey;
+    /**
+     * Apply filter to instances
+     */
+    private applyFilter;
+}
+//# sourceMappingURL=redis-backend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-backend.d.ts","sourceRoot":"","sources":["../../src/backends/redis-backend.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAiB,MAAM,UAAU,CAAC;AACzE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,kBAAuB;IAMzD;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxD;;OAEG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBnD;;OAEG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBlD;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA2B3F;;OAEG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAiBtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAUzC;;OAEG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYrE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,WAAW;CA+BpB"}

package/dist/backends/redis-backend.js

@@ -0,0 +1,200 @@
+"use strict";
+/**
+ * Redis Registry Backend
+ * For production distributed service registry
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisRegistryBackend = void 0;
+const types_1 = require("../types");
+class RedisRegistryBackend {
+    constructor(redis, config = {}) {
+        this.redis = redis;
+        this.keyPrefix = config.keyPrefix || 'hazeljs:discovery:';
+        this.ttl = config.ttl || 90; // 90 seconds default
+    }
+    /**
+     * Register a service instance
+     */
+    async register(instance) {
+        const key = this.getInstanceKey(instance.id);
+        const serviceSetKey = this.getServiceSetKey(instance.name);
+        // Store instance data
+        await this.redis.setex(key, this.ttl, JSON.stringify(instance));
+        // Add to service set
+        await this.redis.sadd(serviceSetKey, instance.id);
+        // Set expiration on service set (will be refreshed on heartbeat)
+        await this.redis.expire(serviceSetKey, this.ttl * 2);
+    }
+    /**
+     * Deregister a service instance
+     */
+    async deregister(instanceId) {
+        const key = this.getInstanceKey(instanceId);
+        // Get instance to find service name
+        const data = await this.redis.get(key);
+        if (data) {
+            const instance = JSON.parse(data);
+            const serviceSetKey = this.getServiceSetKey(instance.name);
+            // Remove from service set
+            await this.redis.srem(serviceSetKey, instanceId);
+            // Delete instance data
+            await this.redis.del(key);
+        }
+    }
+    /**
+     * Update service instance heartbeat
+     */
+    async heartbeat(instanceId) {
+        const key = this.getInstanceKey(instanceId);
+        // Get current instance
+        const data = await this.redis.get(key);
+        if (data) {
+            const instance = JSON.parse(data);
+            // Update heartbeat and status
+            instance.lastHeartbeat = new Date();
+            instance.status = types_1.ServiceStatus.UP;
+            // Update with new TTL
+            await this.redis.setex(key, this.ttl, JSON.stringify(instance));
+            // Refresh service set TTL
+            const serviceSetKey = this.getServiceSetKey(instance.name);
+            await this.redis.expire(serviceSetKey, this.ttl * 2);
+        }
+    }
+    /**
+     * Get all instances of a service
+     */
+    async getInstances(serviceName, filter) {
+        const serviceSetKey = this.getServiceSetKey(serviceName);
+        // Get all instance IDs for this service
+        const instanceIds = await this.redis.smembers(serviceSetKey);
+        if (instanceIds.length === 0) {
+            return [];
+        }
+        // Get all instance data
+        const instances = [];
+        for (const id of instanceIds) {
+            const instance = await this.getInstance(id);
+            if (instance) {
+                instances.push(instance);
+            }
+        }
+        // Apply filters
+        if (filter) {
+            return this.applyFilter(instances, filter);
+        }
+        return instances;
+    }
+    /**
+     * Get a specific service instance
+     */
+    async getInstance(instanceId) {
+        const key = this.getInstanceKey(instanceId);
+        const data = await this.redis.get(key);
+        if (!data) {
+            return null;
+        }
+        const instance = JSON.parse(data);
+        // Convert date strings back to Date objects
+        instance.lastHeartbeat = new Date(instance.lastHeartbeat);
+        instance.registeredAt = new Date(instance.registeredAt);
+        return instance;
+    }
+    /**
+     * Get all registered services
+     */
+    async getAllServices() {
+        const pattern = `${this.keyPrefix}service:*`;
+        const keys = await this.redis.keys(pattern);
+        return keys.map((key) => {
+            const serviceName = key.replace(`${this.keyPrefix}service:`, '');
+            return serviceName;
+        });
+    }
+    /**
+     * Update service instance status
+     */
+    async updateStatus(instanceId, status) {
+        const key = this.getInstanceKey(instanceId);
+        const data = await this.redis.get(key);
+        if (data) {
+            const instance = JSON.parse(data);
+            instance.status = status;
+            await this.redis.setex(key, this.ttl, JSON.stringify(instance));
+        }
+    }
+    /**
+     * Clean up expired instances
+     * Note: Redis handles expiration automatically via TTL
+     */
+    async cleanup() {
+        // Redis automatically removes expired keys
+        // This method can be used for additional cleanup if needed
+        const services = await this.getAllServices();
+        for (const serviceName of services) {
+            const serviceSetKey = this.getServiceSetKey(serviceName);
+            const instanceIds = await this.redis.smembers(serviceSetKey);
+            // Check each instance and remove if expired
+            for (const id of instanceIds) {
+                const exists = await this.redis.exists(this.getInstanceKey(id));
+                if (!exists) {
+                    // Instance key expired but still in set, remove it
+                    await this.redis.srem(serviceSetKey, id);
+                }
+            }
+            // Remove empty service sets
+            const count = await this.redis.scard(serviceSetKey);
+            if (count === 0) {
+                await this.redis.del(serviceSetKey);
+            }
+        }
+    }
+    /**
+     * Close Redis connection
+     */
+    async close() {
+        await this.redis.quit();
+    }
+    /**
+     * Get Redis key for instance
+     */
+    getInstanceKey(instanceId) {
+        return `${this.keyPrefix}instance:${instanceId}`;
+    }
+    /**
+     * Get Redis key for service set
+     */
+    getServiceSetKey(serviceName) {
+        return `${this.keyPrefix}service:${serviceName}`;
+    }
+    /**
+     * Apply filter to instances
+     */
+    applyFilter(instances, filter) {
+        return instances.filter((instance) => {
+            // Filter by zone
+            if (filter.zone && instance.zone !== filter.zone) {
+                return false;
+            }
+            // Filter by status
+            if (filter.status && instance.status !== filter.status) {
+                return false;
+            }
+            // Filter by tags
+            if (filter.tags && filter.tags.length > 0) {
+                if (!instance.tags || !filter.tags.every((tag) => instance.tags.includes(tag))) {
+                    return false;
+                }
+            }
+            // Filter by metadata
+            if (filter.metadata) {
+                for (const [key, value] of Object.entries(filter.metadata)) {
+                    if (!instance.metadata || instance.metadata[key] !== value) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.RedisRegistryBackend = RedisRegistryBackend;