@hazeljs/discovery 0.2.0-beta.1

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;AAI/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;IAK3B;;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;IAMpB;;OAEG;YACW,kBAAkB;IAoBhC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACH,OAAO,CAAC,UAAU;CAgBnB"}

package/dist/registry/service-registry.js

@@ -0,0 +1,148 @@
+"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 axios_1 = __importDefault(require("axios"));
+class ServiceRegistry {
+    constructor(config, backend) {
+        this.config = config;
+        this.instance = null;
+        this.heartbeatInterval = null;
+        this.cleanupInterval = null;
+        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 () => {
+            await this.backend.cleanup();
+        }, 60000); // Run every minute
+    }
+    /**
+     * Perform health check
+     */
+    async performHealthCheck() {
+        if (!this.instance)
+            return;
+        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 {
+            this.instance.status = types_1.ServiceStatus.DOWN;
+            await this.backend.updateStatus(this.instance.id, types_1.ServiceStatus.DOWN);
+        }
+    }
+    /**
+     * 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/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@hazeljs/discovery",
+  "version": "0.2.0-beta.1",
+  "description": "Service discovery and registry for HazelJS microservices - Eureka-inspired with multiple backend support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "test:ci": "jest --coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=clover --no-coverage-threshold",
+    "test:watch": "jest --watch",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@hazeljs/core": "file:../core",
+    "reflect-metadata": "^0.2.2",
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "ioredis": "^5.3.0",
+    "consul": "^1.2.0",
+    "@kubernetes/client-node": "^0.20.0"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    },
+    "consul": {
+      "optional": true
+    },
+    "@kubernetes/client-node": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/discovery"
+  },
+  "keywords": [
+    "hazeljs",
+    "microservices",
+    "service-discovery",
+    "service-registry",
+    "load-balancing",
+    "eureka",
+    "consul",
+    "kubernetes"
+  ],
+  "author": "Muhammad Arslan <marslan@hazeljs.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com"
+}