@hazeljs/discovery 0.2.0-alpha.1

package/dist/load-balancer/strategies.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Load Balancing Strategies
+ */
+import { ServiceInstance, LoadBalancerStrategy } from '../types';
+/**
+ * Base strategy that filters healthy instances
+ */
+declare abstract class BaseStrategy implements LoadBalancerStrategy {
+    abstract name: string;
+    protected filterHealthy(instances: ServiceInstance[]): ServiceInstance[];
+    abstract choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+/**
+ * Round Robin Strategy
+ */
+export declare class RoundRobinStrategy extends BaseStrategy {
+    name: string;
+    private currentIndex;
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+/**
+ * Random Strategy
+ */
+export declare class RandomStrategy extends BaseStrategy {
+    name: string;
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+/**
+ * Least Connections Strategy
+ * Tracks active connections per instance
+ */
+export declare class LeastConnectionsStrategy extends BaseStrategy {
+    name: string;
+    private connections;
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+    incrementConnections(instanceId: string): void;
+    decrementConnections(instanceId: string): void;
+}
+/**
+ * Weighted Round Robin Strategy
+ * Uses metadata.weight for weighted selection
+ */
+export declare class WeightedRoundRobinStrategy extends BaseStrategy {
+    name: string;
+    private currentIndex;
+    private currentWeight;
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+/**
+ * IP Hash Strategy
+ * Consistent hashing based on client IP
+ */
+export declare class IPHashStrategy extends BaseStrategy {
+    name: string;
+    choose(instances: ServiceInstance[], clientIP?: string): ServiceInstance | null;
+    private hashCode;
+}
+/**
+ * Zone Aware Strategy
+ * Prefers instances in the same zone
+ */
+export declare class ZoneAwareStrategy extends BaseStrategy {
+    private preferredZone?;
+    name: string;
+    constructor(preferredZone?: string | undefined);
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+/**
+ * Load Balancer Factory
+ */
+export declare class LoadBalancerFactory {
+    private strategies;
+    constructor();
+    private registerDefaultStrategies;
+    register(strategy: LoadBalancerStrategy): void;
+    get(name: string): LoadBalancerStrategy | undefined;
+    create(name: string, options?: {
+        zone?: string;
+    }): LoadBalancerStrategy;
+}
+export {};
+//# sourceMappingURL=strategies.d.ts.map

package/dist/load-balancer/strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies.d.ts","sourceRoot":"","sources":["../../src/load-balancer/strategies.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAiB,MAAM,UAAU,CAAC;AAEhF;;GAEG;AACH,uBAAe,YAAa,YAAW,oBAAoB;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,aAAa,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE;IAIxE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;CACtE;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,IAAI,SAAiB;IACrB,OAAO,CAAC,YAAY,CAAK;IAEzB,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;CAQ7D;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC9C,IAAI,SAAY;IAEhB,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;CAO7D;AAED;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,YAAY;IACxD,IAAI,SAAuB;IAC3B,OAAO,CAAC,WAAW,CAA6B;IAEhD,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;IAmB5D,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAK9C,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;CAI/C;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,YAAY;IAC1D,IAAI,SAA0B;IAC9B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,aAAa,CAAK;IAE1B,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;CAoB7D;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC9C,IAAI,SAAa;IAEjB,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAW/E,OAAO,CAAC,QAAQ;CASjB;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IAGrC,OAAO,CAAC,aAAa,CAAC;IAFlC,IAAI,SAAgB;gBAEA,aAAa,CAAC,EAAE,MAAM,YAAA;IAI1C,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI;CAe7D;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,UAAU,CAA2C;;IAM7D,OAAO,CAAC,yBAAyB;IAQjC,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAI9C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAInD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,oBAAoB;CAWxE"}

package/dist/load-balancer/strategies.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Load Balancing Strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerFactory = exports.ZoneAwareStrategy = exports.IPHashStrategy = exports.WeightedRoundRobinStrategy = exports.LeastConnectionsStrategy = exports.RandomStrategy = exports.RoundRobinStrategy = void 0;
+const types_1 = require("../types");
+/**
+ * Base strategy that filters healthy instances
+ */
+class BaseStrategy {
+    filterHealthy(instances) {
+        return instances.filter((instance) => instance.status === types_1.ServiceStatus.UP);
+    }
+}
+/**
+ * Round Robin Strategy
+ */
+class RoundRobinStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'round-robin';
+        this.currentIndex = 0;
+    }
+    choose(instances) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        const instance = healthy[this.currentIndex % healthy.length];
+        this.currentIndex = (this.currentIndex + 1) % healthy.length;
+        return instance;
+    }
+}
+exports.RoundRobinStrategy = RoundRobinStrategy;
+/**
+ * Random Strategy
+ */
+class RandomStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'random';
+    }
+    choose(instances) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        const randomIndex = Math.floor(Math.random() * healthy.length);
+        return healthy[randomIndex];
+    }
+}
+exports.RandomStrategy = RandomStrategy;
+/**
+ * Least Connections Strategy
+ * Tracks active connections per instance
+ */
+class LeastConnectionsStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'least-connections';
+        this.connections = new Map();
+    }
+    choose(instances) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        // Find instance with least connections
+        let minConnections = Infinity;
+        let selectedInstance = null;
+        for (const instance of healthy) {
+            const connections = this.connections.get(instance.id) || 0;
+            if (connections < minConnections) {
+                minConnections = connections;
+                selectedInstance = instance;
+            }
+        }
+        return selectedInstance;
+    }
+    incrementConnections(instanceId) {
+        const current = this.connections.get(instanceId) || 0;
+        this.connections.set(instanceId, current + 1);
+    }
+    decrementConnections(instanceId) {
+        const current = this.connections.get(instanceId) || 0;
+        this.connections.set(instanceId, Math.max(0, current - 1));
+    }
+}
+exports.LeastConnectionsStrategy = LeastConnectionsStrategy;
+/**
+ * Weighted Round Robin Strategy
+ * Uses metadata.weight for weighted selection
+ */
+class WeightedRoundRobinStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'weighted-round-robin';
+        this.currentIndex = 0;
+        this.currentWeight = 0;
+    }
+    choose(instances) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        // Build weighted list
+        const weighted = [];
+        for (const instance of healthy) {
+            const weightValue = instance.metadata?.weight;
+            const weight = typeof weightValue === 'number' && weightValue > 0 ? weightValue : 1;
+            for (let i = 0; i < weight; i++) {
+                weighted.push(instance);
+            }
+        }
+        if (weighted.length === 0)
+            return null;
+        const instance = weighted[this.currentIndex % weighted.length];
+        this.currentIndex = (this.currentIndex + 1) % weighted.length;
+        return instance;
+    }
+}
+exports.WeightedRoundRobinStrategy = WeightedRoundRobinStrategy;
+/**
+ * IP Hash Strategy
+ * Consistent hashing based on client IP
+ */
+class IPHashStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'ip-hash';
+    }
+    choose(instances, clientIP) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        if (!clientIP)
+            return healthy[0];
+        // Simple hash function
+        const hash = this.hashCode(clientIP);
+        const index = Math.abs(hash) % healthy.length;
+        return healthy[index];
+    }
+    hashCode(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    }
+}
+exports.IPHashStrategy = IPHashStrategy;
+/**
+ * Zone Aware Strategy
+ * Prefers instances in the same zone
+ */
+class ZoneAwareStrategy extends BaseStrategy {
+    constructor(preferredZone) {
+        super();
+        this.preferredZone = preferredZone;
+        this.name = 'zone-aware';
+    }
+    choose(instances) {
+        const healthy = this.filterHealthy(instances);
+        if (healthy.length === 0)
+            return null;
+        // Try to find instance in preferred zone
+        if (this.preferredZone) {
+            const sameZone = healthy.filter((i) => i.zone === this.preferredZone);
+            if (sameZone.length > 0) {
+                return sameZone[Math.floor(Math.random() * sameZone.length)];
+            }
+        }
+        // Fallback to random
+        return healthy[Math.floor(Math.random() * healthy.length)];
+    }
+}
+exports.ZoneAwareStrategy = ZoneAwareStrategy;
+/**
+ * Load Balancer Factory
+ */
+class LoadBalancerFactory {
+    constructor() {
+        this.strategies = new Map();
+        this.registerDefaultStrategies();
+    }
+    registerDefaultStrategies() {
+        this.register(new RoundRobinStrategy());
+        this.register(new RandomStrategy());
+        this.register(new LeastConnectionsStrategy());
+        this.register(new WeightedRoundRobinStrategy());
+        this.register(new IPHashStrategy());
+    }
+    register(strategy) {
+        this.strategies.set(strategy.name, strategy);
+    }
+    get(name) {
+        return this.strategies.get(name);
+    }
+    create(name, options) {
+        if (name === 'zone-aware') {
+            return new ZoneAwareStrategy(options?.zone);
+        }
+        const strategy = this.get(name);
+        if (!strategy) {
+            throw new Error(`Load balancing strategy '${name}' not found`);
+        }
+        return strategy;
+    }
+}
+exports.LoadBalancerFactory = LoadBalancerFactory;

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

@@ -0,0 +1,51 @@
+/**
+ * Service Registry
+ * Manages service registration and health checks
+ */
+import { ServiceInstance, ServiceRegistryConfig } from '../types';
+import { RegistryBackend } from '../backends/registry-backend';
+export declare class ServiceRegistry {
+    private config;
+    private backend;
+    private instance;
+    private heartbeatInterval;
+    private cleanupInterval;
+    constructor(config: ServiceRegistryConfig, backend?: RegistryBackend);
+    /**
+     * Register this service instance
+     */
+    register(): Promise<void>;
+    /**
+     * Deregister this service instance
+     */
+    deregister(): Promise<void>;
+    /**
+     * Get the current service instance
+     */
+    getInstance(): ServiceInstance | null;
+    /**
+     * Get the backend
+     */
+    getBackend(): RegistryBackend;
+    /**
+     * Start heartbeat interval
+     */
+    private startHeartbeat;
+    /**
+     * Start cleanup interval
+     */
+    private startCleanup;
+    /**
+     * Perform health check
+     */
+    private performHealthCheck;
+    /**
+     * Generate unique instance ID
+     */
+    private generateInstanceId;
+    /**
+     * Get local IP address
+     */
+    private getLocalIP;
+}
+//# sourceMappingURL=service-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-registry.d.ts","sourceRoot":"","sources":["../../src/registry/service-registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAiB,MAAM,UAAU,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAM/D,qBAAa,eAAe;IAOxB,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,eAAe,CAA+B;gBAG5C,MAAM,EAAE,qBAAqB,EACrC,OAAO,CAAC,EAAE,eAAe;IAO3B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC/B;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBjC;;OAEG;IACH,WAAW,IAAI,eAAe,GAAG,IAAI;IAIrC;;OAEG;IACH,UAAU,IAAI,eAAe;IAI7B;;OAEG;IACH,OAAO,CAAC,cAAc;IAYtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;YACW,kBAAkB;IA0BhC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACH,OAAO,CAAC,UAAU;CAgBnB"}

package/dist/registry/service-registry.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * Service Registry
+ * Manages service registration and health checks
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceRegistry = void 0;
+const types_1 = require("../types");
+const memory_backend_1 = require("../backends/memory-backend");
+const logger_1 = require("../utils/logger");
+const validation_1 = require("../utils/validation");
+const axios_1 = __importDefault(require("axios"));
+class ServiceRegistry {
+    constructor(config, backend) {
+        this.config = config;
+        this.instance = null;
+        this.heartbeatInterval = null;
+        this.cleanupInterval = null;
+        (0, validation_1.validateServiceRegistryConfig)(config);
+        this.backend = backend || new memory_backend_1.MemoryRegistryBackend();
+    }
+    /**
+     * Register this service instance
+     */
+    async register() {
+        const host = this.config.host || this.getLocalIP();
+        const instanceId = this.generateInstanceId(this.config.name, host, this.config.port);
+        this.instance = {
+            id: instanceId,
+            name: this.config.name,
+            host,
+            port: this.config.port,
+            protocol: this.config.protocol || 'http',
+            metadata: this.config.metadata || {},
+            healthCheckPath: this.config.healthCheckPath || '/health',
+            healthCheckInterval: this.config.healthCheckInterval || 30000,
+            zone: this.config.zone,
+            tags: this.config.tags || [],
+            status: types_1.ServiceStatus.STARTING,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+        };
+        await this.backend.register(this.instance);
+        // Start heartbeat
+        this.startHeartbeat();
+        // Start cleanup task
+        this.startCleanup();
+        // Perform initial health check
+        await this.performHealthCheck();
+    }
+    /**
+     * Deregister this service instance
+     */
+    async deregister() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.instance) {
+            await this.backend.deregister(this.instance.id);
+            this.instance = null;
+        }
+    }
+    /**
+     * Get the current service instance
+     */
+    getInstance() {
+        return this.instance;
+    }
+    /**
+     * Get the backend
+     */
+    getBackend() {
+        return this.backend;
+    }
+    /**
+     * Start heartbeat interval
+     */
+    startHeartbeat() {
+        if (!this.instance)
+            return;
+        const interval = this.instance.healthCheckInterval || 30000;
+        this.heartbeatInterval = setInterval(async () => {
+            if (this.instance) {
+                await this.performHealthCheck();
+            }
+        }, interval);
+    }
+    /**
+     * Start cleanup interval
+     */
+    startCleanup() {
+        this.cleanupInterval = setInterval(async () => {
+            try {
+                await this.backend.cleanup();
+            }
+            catch (error) {
+                const logger = logger_1.DiscoveryLogger.getLogger();
+                logger.error('Cleanup task failed', error);
+            }
+        }, 60000); // Run every minute
+    }
+    /**
+     * Perform health check
+     */
+    async performHealthCheck() {
+        if (!this.instance)
+            return;
+        const logger = logger_1.DiscoveryLogger.getLogger();
+        try {
+            const url = `${this.instance.protocol}://${this.instance.host}:${this.instance.port}${this.instance.healthCheckPath}`;
+            const response = await axios_1.default.get(url, { timeout: 5000 });
+            if (response.status === 200) {
+                this.instance.status = types_1.ServiceStatus.UP;
+                await this.backend.heartbeat(this.instance.id);
+            }
+            else {
+                this.instance.status = types_1.ServiceStatus.DOWN;
+                await this.backend.updateStatus(this.instance.id, types_1.ServiceStatus.DOWN);
+            }
+        }
+        catch (error) {
+            this.instance.status = types_1.ServiceStatus.DOWN;
+            await this.backend.updateStatus(this.instance.id, types_1.ServiceStatus.DOWN);
+            logger.warn(`Health check failed for ${this.instance.name} (${this.instance.id}), marking as DOWN`, error);
+        }
+    }
+    /**
+     * Generate unique instance ID
+     */
+    generateInstanceId(name, host, port) {
+        return `${name}:${host}:${port}:${Date.now()}`;
+    }
+    /**
+     * Get local IP address
+     */
+    getLocalIP() {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { networkInterfaces } = require('os');
+        const nets = networkInterfaces();
+        for (const name of Object.keys(nets)) {
+            for (const net of nets[name]) {
+                // Skip internal and non-IPv4 addresses
+                if (net.family === 'IPv4' && !net.internal) {
+                    return net.address;
+                }
+            }
+        }
+        return 'localhost';
+    }
+}
+exports.ServiceRegistry = ServiceRegistry;

package/dist/types/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Service Discovery Types
+ */
+export interface ServiceInstance {
+    id: string;
+    name: string;
+    host: string;
+    port: number;
+    protocol?: 'http' | 'https' | 'grpc';
+    metadata?: Record<string, unknown>;
+    healthCheckPath?: string;
+    healthCheckInterval?: number;
+    zone?: string;
+    tags?: string[];
+    status: ServiceStatus;
+    lastHeartbeat: Date;
+    registeredAt: Date;
+}
+export declare enum ServiceStatus {
+    UP = "UP",
+    DOWN = "DOWN",
+    STARTING = "STARTING",
+    OUT_OF_SERVICE = "OUT_OF_SERVICE",
+    UNKNOWN = "UNKNOWN"
+}
+export interface ServiceRegistryConfig {
+    name: string;
+    host?: string;
+    port: number;
+    protocol?: 'http' | 'https' | 'grpc';
+    healthCheckPath?: string;
+    healthCheckInterval?: number;
+    metadata?: Record<string, unknown>;
+    zone?: string;
+    tags?: string[];
+    backend?: 'memory' | 'redis' | 'consul' | 'etcd' | 'kubernetes';
+    backendConfig?: Record<string, unknown>;
+}
+export interface DiscoveryClientConfig {
+    backend?: 'memory' | 'redis' | 'consul' | 'etcd' | 'kubernetes';
+    backendConfig?: Record<string, unknown>;
+    cacheEnabled?: boolean;
+    cacheTTL?: number;
+    refreshInterval?: number;
+}
+export interface LoadBalancerStrategy {
+    name: string;
+    choose(instances: ServiceInstance[]): ServiceInstance | null;
+}
+export interface HealthCheckResult {
+    status: ServiceStatus;
+    message?: string;
+    timestamp: Date;
+}
+export interface ServiceFilter {
+    zone?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    status?: ServiceStatus;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;IACtB,aAAa,EAAE,IAAI,CAAC;IACpB,YAAY,EAAE,IAAI,CAAC;CACpB;AAED,oBAAY,aAAa;IACvB,EAAE,OAAO;IACT,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,cAAc,mBAAmB;IACjC,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,YAAY,CAAC;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,YAAY,CAAC;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,eAAe,GAAG,IAAI,CAAC;CAC9D;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB"}

package/dist/types/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Service Discovery Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceStatus = void 0;
+var ServiceStatus;
+(function (ServiceStatus) {
+    ServiceStatus["UP"] = "UP";
+    ServiceStatus["DOWN"] = "DOWN";
+    ServiceStatus["STARTING"] = "STARTING";
+    ServiceStatus["OUT_OF_SERVICE"] = "OUT_OF_SERVICE";
+    ServiceStatus["UNKNOWN"] = "UNKNOWN";
+})(ServiceStatus || (exports.ServiceStatus = ServiceStatus = {}));

package/dist/utils/filter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared filter utility for service instances
+ */
+import { ServiceInstance, ServiceFilter } from '../types';
+/**
+ * Apply a ServiceFilter to an array of ServiceInstances.
+ * Returns only instances matching all specified filter criteria.
+ */
+export declare function applyServiceFilter(instances: ServiceInstance[], filter?: ServiceFilter): ServiceInstance[];
+//# sourceMappingURL=filter.d.ts.map

package/dist/utils/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/utils/filter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE1D;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,eAAe,EAAE,EAC5B,MAAM,CAAC,EAAE,aAAa,GACrB,eAAe,EAAE,CAgCnB"}

package/dist/utils/filter.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Shared filter utility for service instances
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyServiceFilter = applyServiceFilter;
+/**
+ * Apply a ServiceFilter to an array of ServiceInstances.
+ * Returns only instances matching all specified filter criteria.
+ */
+function applyServiceFilter(instances, filter) {
+    if (!filter)
+        return instances;
+    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;
+    });
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Pluggable logger for @hazeljs/discovery
+ *
+ * Consumers can supply their own logger via DiscoveryLogger.setLogger().
+ * The default logger writes to the console.
+ */
+export interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+export declare const DiscoveryLogger: {
+    /** Replace the default console logger with a custom implementation */
+    setLogger(logger: Logger): void;
+    /** Reset to the default console logger */
+    resetLogger(): void;
+    /** Get the current logger instance */
+    getLogger(): Logger;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IACjD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChD,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CAClD;AAeD,eAAO,MAAM,eAAe;IAC1B,sEAAsE;sBACpD,MAAM,GAAG,IAAI;IAI/B,0CAA0C;mBAC3B,IAAI;IAInB,sCAAsC;iBACzB,MAAM;CAGpB,CAAC"}