@hazeljs/discovery 0.2.0-alpha.1

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

@@ -0,0 +1,103 @@
+/**
+ * Kubernetes Registry Backend
+ * Uses Kubernetes Service Discovery
+ */
+import { RegistryBackend } from './registry-backend';
+import { ServiceInstance, ServiceFilter } from '../types';
+/**
+ * Minimal type definitions for the Kubernetes client API surface we use.
+ * These mirror the shapes exposed by `@kubernetes/client-node`.
+ */
+export interface KubeConfig {
+    makeApiClient(apiClass: new () => any): any;
+}
+export interface K8sEndpointAddress {
+    ip: string;
+    targetRef?: {
+        name?: string;
+    };
+    nodeName?: string;
+}
+export interface K8sEndpointPort {
+    port: number;
+}
+export interface K8sEndpointSubset {
+    ports?: K8sEndpointPort[];
+    addresses?: K8sEndpointAddress[];
+    notReadyAddresses?: K8sEndpointAddress[];
+}
+export interface K8sObjectMeta {
+    name?: string;
+    annotations?: Record<string, string>;
+    labels?: Record<string, string>;
+    creationTimestamp?: string;
+}
+export interface K8sEndpoints {
+    metadata?: K8sObjectMeta;
+    subsets?: K8sEndpointSubset[];
+}
+export interface K8sService {
+    metadata?: K8sObjectMeta;
+}
+export interface K8sApiResponse<T> {
+    body: T;
+}
+export interface CoreV1ApiLike {
+    readNamespacedEndpoints(name: string, namespace: string): Promise<K8sApiResponse<K8sEndpoints>>;
+    listNamespacedService(namespace: string, pretty?: string, allowWatchBookmarks?: boolean, _continue?: string, fieldSelector?: string, labelSelector?: string): Promise<K8sApiResponse<{
+        items: K8sService[];
+    }>>;
+}
+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;
+}
+//# 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;AAKzE;;;GAGG;AACH,MAAM,WAAW,UAAU;IAEzB,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,GAAG,GAAG,CAAC;CAC7C;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,eAAe,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACjC,iBAAiB,CAAC,EAAE,kBAAkB,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,OAAO,CAAC,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,aAAa,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,IAAI,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,aAAa;IAC5B,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC;IAChG,qBAAqB,CACnB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,EACf,mBAAmB,CAAC,EAAE,OAAO,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,cAAc,CAAC;QAAE,KAAK,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC,CAAC,CAAC;CACrD;AAED,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,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,UAAU,EAAE,UAAU,EAAE,MAAM,GAAE,uBAA4B;IAWxE;;;;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;IA4D3F;;OAEG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAQtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAoBzC;;;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;CAiC9B"}

package/dist/backends/kubernetes-backend.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Kubernetes Registry Backend
+ * Uses Kubernetes Service Discovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KubernetesRegistryBackend = 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 KubernetesRegistryBackend {
+    constructor(kubeConfig, config = {}) {
+        (0, validation_1.validateKubernetesBackendConfig)(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) {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        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
+            return (0, filter_1.applyServiceFilter)(instances, filter);
+        }
+        catch (error) {
+            logger.error(`Failed to get instances for service "${serviceName}" from Kubernetes`, error);
+            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() {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        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 (error) {
+            logger.error('Failed to list services from Kubernetes', error);
+            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()),
+        };
+    }
+}
+exports.KubernetesRegistryBackend = KubernetesRegistryBackend;

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

@@ -0,0 +1,21 @@
+/**
+ * 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>;
+}
+//# 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;AAGzE,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;IAgBrF,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;CAe/B"}

package/dist/backends/memory-backend.js

@@ -0,0 +1,86 @@
+"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");
+const filter_1 = require("../utils/filter");
+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 [];
+        const instances = [];
+        for (const id of instanceIds) {
+            const instance = this.instances.get(id);
+            if (instance) {
+                instances.push(instance);
+            }
+        }
+        // Apply filters
+        return (0, filter_1.applyServiceFilter)(instances, filter);
+    }
+    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);
+        }
+    }
+}
+exports.MemoryRegistryBackend = MemoryRegistryBackend;

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

@@ -0,0 +1,76 @@
+/**
+ * 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;
+    private connected;
+    constructor(redis: Redis, config?: RedisBackendConfig);
+    /**
+     * Set up Redis connection event handlers for resilience
+     */
+    private setupConnectionHandlers;
+    /**
+     * Check Redis connectivity before operations
+     */
+    private ensureConnected;
+    /**
+     * 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 (uses MGET for efficiency)
+     */
+    getInstances(serviceName: string, filter?: ServiceFilter): Promise<ServiceInstance[]>;
+    /**
+     * Get a specific service instance
+     */
+    getInstance(instanceId: string): Promise<ServiceInstance | null>;
+    /**
+     * Get all registered services using SCAN (safe for production)
+     */
+    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;
+}
+//# 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;AAIzE,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;IAC7B,OAAO,CAAC,SAAS,CAAQ;gBAEb,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,kBAAuB;IAUzD;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAuB/B;;OAEG;IACH,OAAO,CAAC,eAAe;IAMvB;;OAEG;IACG,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxD;;OAEG;IACG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBnD;;OAEG;IACG,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBlD;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA8B3F;;OAEG;IACG,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAmBtE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAoBzC;;OAEG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcrE;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA6B9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAGzB"}

package/dist/backends/redis-backend.js

@@ -0,0 +1,220 @@
+"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");
+const filter_1 = require("../utils/filter");
+const logger_1 = require("../utils/logger");
+const validation_1 = require("../utils/validation");
+class RedisRegistryBackend {
+    constructor(redis, config = {}) {
+        this.connected = true;
+        (0, validation_1.validateRedisBackendConfig)(config);
+        this.redis = redis;
+        this.keyPrefix = config.keyPrefix || 'hazeljs:discovery:';
+        this.ttl = config.ttl || 90; // 90 seconds default
+        this.setupConnectionHandlers();
+    }
+    /**
+     * Set up Redis connection event handlers for resilience
+     */
+    setupConnectionHandlers() {
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        this.redis.on('error', (err) => {
+            this.connected = false;
+            logger.error('Redis connection error', err);
+        });
+        this.redis.on('connect', () => {
+            this.connected = true;
+            logger.info('Redis connected');
+        });
+        this.redis.on('reconnecting', () => {
+            logger.warn('Redis reconnecting...');
+        });
+        this.redis.on('close', () => {
+            this.connected = false;
+            logger.warn('Redis connection closed');
+        });
+    }
+    /**
+     * Check Redis connectivity before operations
+     */
+    ensureConnected() {
+        if (!this.connected) {
+            throw new Error('Redis backend is not connected');
+        }
+    }
+    /**
+     * Register a service instance
+     */
+    async register(instance) {
+        this.ensureConnected();
+        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) {
+        this.ensureConnected();
+        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) {
+        this.ensureConnected();
+        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 (uses MGET for efficiency)
+     */
+    async getInstances(serviceName, filter) {
+        this.ensureConnected();
+        const serviceSetKey = this.getServiceSetKey(serviceName);
+        // Get all instance IDs for this service
+        const instanceIds = await this.redis.smembers(serviceSetKey);
+        if (instanceIds.length === 0) {
+            return [];
+        }
+        // Batch-fetch all instances with MGET
+        const keys = instanceIds.map((id) => this.getInstanceKey(id));
+        const results = await this.redis.mget(...keys);
+        const instances = [];
+        for (const data of results) {
+            if (data) {
+                const instance = JSON.parse(data);
+                instance.lastHeartbeat = new Date(instance.lastHeartbeat);
+                instance.registeredAt = new Date(instance.registeredAt);
+                instances.push(instance);
+            }
+        }
+        // Apply filters
+        return (0, filter_1.applyServiceFilter)(instances, filter);
+    }
+    /**
+     * Get a specific service instance
+     */
+    async getInstance(instanceId) {
+        this.ensureConnected();
+        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 using SCAN (safe for production)
+     */
+    async getAllServices() {
+        this.ensureConnected();
+        const pattern = `${this.keyPrefix}service:*`;
+        const prefixLen = `${this.keyPrefix}service:`.length;
+        const services = [];
+        let cursor = '0';
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = nextCursor;
+            for (const key of keys) {
+                services.push(key.substring(prefixLen));
+            }
+        } while (cursor !== '0');
+        return services;
+    }
+    /**
+     * Update service instance status
+     */
+    async updateStatus(instanceId, status) {
+        this.ensureConnected();
+        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() {
+        this.ensureConnected();
+        // Redis automatically removes expired keys
+        // This method cleans up stale entries in service sets
+        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}`;
+    }
+}
+exports.RedisRegistryBackend = RedisRegistryBackend;