ninja-reverse-proxy 1.0.0

package/README.md

@@ -0,0 +1,480 @@
+# Ninja Reverse Proxy
+
+A production-grade, backend-agnostic **Layer 7 Reverse Proxy** built from scratch in **TypeScript** and **Node.js**.
+
+Designed in the same philosophy as **Nginx**, **Traefik**, and **HAProxy** — configure it once, point it at any backend, and it handles everything else.
+
+```
+Developer → GitHub → Jenkins CI/CD → Docker → Any Backend
+```
+
+---
+
+## What it is
+
+Ninja Reverse Proxy is a fully configurable, self-contained reverse proxy that works with **any HTTP backend**:
+
+- Express · Fastify · NestJS
+- Django · FastAPI · Flask
+- Spring Boot · Quarkus
+- Go (net/http, Gin, Echo)
+- ASP.NET Core
+- Kubernetes Services
+- Docker Compose services
+- Any service that speaks HTTP
+
+The proxy never cares what technology runs behind the URLs. You configure upstreams in `config.yaml` and the proxy routes, balances, caches, rate-limits, and health-checks them automatically.
+
+---
+
+## Features
+
+| Feature | Details |
+|---|---|
+| **Cluster Architecture** | Master/Worker pattern via Node.js `cluster` — uses all CPU cores |
+| **Round-Robin Load Balancing** | Equal request distribution across healthy upstreams |
+| **Circuit Breaker** | Marks upstreams DOWN after configurable failure threshold |
+| **Redis Response Cache** | GET response caching with configurable TTL; auto-invalidated on writes |
+| **Per-Route Rate Limiting** | Sliding window rate limiter per client IP per route |
+| **Service Registry** | Backends self-register, deregister, and send heartbeats |
+| **Continuous Health Checks** | Every 10 seconds — auto-removes and auto-recovers upstreams |
+| **HTTPS / TLS Termination** | Full SSL at the proxy; all HTTP auto-redirected (301) |
+| **Auto Scaling** | Optionally spawns/kills upstream servers dynamically based on load |
+| **Retry Logic** | Up to 2 retries on upstream failure, each on a different worker |
+| **Graceful Shutdown** | Drains all connections on SIGTERM / SIGINT |
+| **Admin API** | Live stats for load balancer, cache, registry, auto scaler |
+| **YAML Configuration** | One file, fully validated with Zod — no source code changes needed |
+| **Docker + Kubernetes** | Ships with Compose and K8s manifests out of the box |
+| **Jenkins CI/CD** | Declarative pipeline included |
+| **SonarQube** | `sonar-project.properties` included for static analysis |
+
+---
+
+## Architecture
+
+```
+                    ┌─────────────────────────────────────────────────┐
+                    │               Ninja Reverse Proxy                │
+                    │                                                   │
+  Client ──HTTPS──► │  Master Process                                   │
+                    │    ├── Rate Limiter (per-IP, per-route)           │
+                    │    ├── Redis Cache (GET responses)                │
+                    │    ├── Load Balancer (round-robin / ip-hash / …)  │
+                    │    ├── Health Checker (every 10s)                 │
+                    │    ├── Service Registry                           │
+                    │    └── Auto Scaler (optional)                     │
+                    │                                                   │
+                    │  Worker Processes (one per CPU core)              │
+                    │    └── Forward requests via keepAlive TCP         │
+                    └───────────┬─────────────────────────────────────┘
+                                │
+                ┌───────────────┼───────────────┐
+                ▼               ▼               ▼
+           backend-a       backend-b       backend-c
+         (Express)       (Django)        (Spring Boot)
+```
+
+### CI/CD Flow
+
+```
+Developer
+  │ edits code / config
+  ▼
+GitHub
+  ▼
+Jenkins (Jenkinsfile)
+  ├── Setup (npm ci)
+  ├── Static Analysis — Lint + npm audit (parallel)
+  ├── Unit Tests
+  ├── Build Artifact (tsc)
+  └── Deploy to Production (main branch, prod env)
+```
+
+---
+
+## Quick Start
+
+### 1. Clone and generate TLS certificates
+
+```bash
+git clone https://github.com/praveenkumar-co/reverse-proxy.git
+cd reverse-proxy
+
+# Generate a self-signed certificate (for development)
+openssl req -x509 -newkey rsa:4096 \
+  -keyout key.pem -out cert.pem \
+  -days 365 -nodes
+```
+
+### 2. Configure your backends
+
+```bash
+cp config.example.yaml config.yaml
+```
+
+Edit `config.yaml` — replace the example upstreams with your real backend URLs:
+
+```yaml
+upstreams:
+  - id: my-api
+    url: http://my-api:8000
+
+  - id: my-frontend
+    url: http://my-frontend:3000
+```
+
+### 3. Run
+
+```bash
+# Proxy + Redis only (you bring your own backends)
+docker-compose up --build
+
+# Or run the built-in demo (backend-a + backend-b included)
+cd examples/docker-compose && docker-compose up --build
+```
+
+### 4. Test
+
+```bash
+curl -k https://localhost:8443/
+curl -k https://localhost:8443/__lb-stats
+curl -k https://localhost:8443/__registry
+```
+
+---
+
+## Configuration Reference
+
+`config.example.yaml` is the fully commented template. Copy it to `config.yaml` to get started.
+
+```yaml
+server:
+
+  listen: 8080          # HTTP port — redirects all traffic to HTTPS
+  httpsPort: 8443       # HTTPS port — main entry point
+  workers: 2            # Set to your CPU core count (run: nproc)
+
+  loadBalancing:
+    strategy: round-robin           # round-robin | least-connections | ip-hash | random
+    failureThreshold: 3             # Mark upstream DOWN after 3 consecutive failures
+    recoveryTimeMs: 15000           # Retry a DOWN upstream after 15 seconds
+
+  autoScaling:
+    enabled: false                  # false → static backends (like Nginx)
+                                    # true  → dynamic server spawning based on load
+    minServers: 2
+    maxServers: 10
+    scaleUpAt: 10                   # Spawn a server when connections exceed this
+    scaleDownAt: 2                  # Kill a server when connections drop below this
+    cooldownMs: 60000
+    startPort: 9000
+    proxyPort: 8080
+
+  cache:
+    enabled: false                  # true → cache GET responses in Redis
+    host: redis
+    port: 6379
+    ttlSeconds: 60
+
+  upstreams:
+    - id: backend-a                 # Any name — used to reference in paths
+      url: http://backend-a:3001    # Any HTTP URL — any technology
+
+    - id: backend-b
+      url: http://backend-b:3002
+
+  paths:
+    - path: /                       # Route all traffic to both backends
+      upstream:
+        - backend-a
+        - backend-b
+      rateLimit:
+        windowMs: 60000             # 1-minute window
+        maxRequests: 100000         # per client IP
+
+    - path: /api                    # Route /api to a specific backend only
+      upstream:
+        - backend-a
+
+  headers:
+    - key: X-Forwarded-For
+      value: client_ip
+    - key: X-Real-IP
+      value: client_ip
+```
+
+---
+
+## Docker
+
+### Build the proxy image
+
+```bash
+docker build -t ninja-reverse-proxy:latest .
+```
+
+### Run with Docker Compose (proxy + Redis only)
+
+```bash
+# Uses docker-compose.yml in project root
+docker-compose up --build
+```
+
+Your own backend services connect to the `proxy-network` and are listed in `config.yaml`.
+
+### Run the full built-in demo
+
+```bash
+# Spins up proxy + redis + backend-a + backend-b
+cd examples/docker-compose
+docker-compose up --build
+```
+
+### Connect your real app
+
+Add your app as a service in your own `docker-compose.yml` and connect it to the proxy network:
+
+```yaml
+services:
+
+  my-express-app:
+    image: my-express-app:latest
+    networks:
+      - proxy-network
+
+networks:
+  proxy-network:
+    external: true
+    name: reverse-proxy_proxy-network
+```
+
+Then add it to `config.yaml`:
+
+```yaml
+upstreams:
+  - id: my-express-app
+    url: http://my-express-app:3000
+```
+
+---
+
+## Kubernetes
+
+See [`k8s/README.md`](k8s/README.md) for the full deployment guide.
+
+Quick overview:
+
+```bash
+# Apply all manifests
+kubectl apply -f k8s/
+
+# Port-forward for local testing
+kubectl port-forward svc/ninja-reverse-proxy-svc 8080:8080 8443:8443
+
+# Verify
+curl -k https://localhost:8443/__lb-stats
+```
+
+The proxy config is mounted as a Kubernetes ConfigMap — change it without rebuilding the image.
+
+---
+
+## Auto Scaler
+
+The Auto Scaler is **fully optional** and controlled entirely by `config.yaml`.
+
+### Static mode (default — works like Nginx)
+
+```yaml
+autoScaling:
+  enabled: false
+```
+
+The proxy uses only the upstream servers listed in `config.yaml`. This is appropriate for production setups where you manage your own backend services.
+
+### Dynamic mode
+
+```yaml
+autoScaling:
+  enabled: true
+  minServers: 2
+  maxServers: 10
+  scaleUpAt: 10       # spawn a new server when total active connections exceed this
+  scaleDownAt: 2      # kill the oldest server when connections drop below this
+  cooldownMs: 60000   # minimum wait between scale events
+```
+
+When enabled, the proxy dynamically spawns (`server-template.js`) and kills backend servers based on active connection count. See `examples/docker-compose/` for a working demonstration.
+
+---
+
+## Admin API
+
+All admin endpoints are available on the HTTPS port.
+
+| Endpoint | Method | Description |
+|---|---|---|
+| `/__lb-stats` | GET | Load balancer stats + healthy upstreams |
+| `/__cache-stats` | GET | Redis cache hit/miss stats |
+| `/__registry` | GET | All registered services |
+| `/__autoscaler-stats` | GET | Auto scaler status |
+| `/__registry/register` | POST | Register a new upstream |
+| `/__registry/deregister/:id` | DELETE | Deregister an upstream |
+| `/__registry/heartbeat/:id` | PUT | Upstream heartbeat ping |
+
+```bash
+curl -k https://localhost:8443/__lb-stats
+curl -k https://localhost:8443/__cache-stats
+curl -k https://localhost:8443/__registry
+curl -k https://localhost:8443/__autoscaler-stats
+```
+
+---
+
+## Jenkins CI/CD Pipeline
+
+A declarative `Jenkinsfile` is included in the project root.
+
+**Pipeline stages:**
+
+1. **Setup** — `npm ci` (deterministic install)
+2. **Static Analysis** — Lint + `npm audit` (parallel)
+3. **Unit Tests** — conditional on `RUN_TESTS` parameter
+4. **Build Artifact** — `npm run build` (TypeScript → JavaScript)
+5. **Deploy to Production** — branch `main` + `ENV_TYPE=prod` + manual approval gate
+
+**Global options:** 1-hour timeout · last 10 builds retained · no concurrent builds · timestamps on every log line.
+
+---
+
+## SonarQube
+
+`sonar-project.properties` is included. To run a scan:
+
+```bash
+sonar-scanner \
+  -Dsonar.host.url=http://localhost:9000 \
+  -Dsonar.login=YOUR_SONAR_TOKEN
+```
+
+Scans the `src/` directory. Excludes `node_modules/`, `dist/`, certificates, and CI files.
+
+---
+
+## Security Scanning (Trivy)
+
+```bash
+# Scan dependencies
+trivy fs .
+
+# Scan the Docker image
+docker build -t ninja-reverse-proxy:latest .
+trivy image ninja-reverse-proxy:latest
+```
+
+---
+
+## Project Structure
+
+```
+ninja-reverse-proxy/
+├── src/                           ← Proxy source (TypeScript)
+│   ├── index.ts                   → CLI entry point
+│   ├── server.ts                  → Master + Worker proxy engine
+│   ├── loadBalancer.ts            → Round-robin with circuit breaker
+│   ├── auto-scaler.ts             → Dynamic server scaling
+│   ├── health.ts                  → Health checker (initial + continuous)
+│   ├── Serviceregistry.ts         → Service registry (register/heartbeat/deregister)
+│   ├── cache.ts                   → Redis cache (get/set/invalidate/stats)
+│   ├── rate-limiter.ts            → Sliding window rate limiter
+│   ├── config-schema.ts           → Zod config validation schema
+│   ├── config.ts                  → YAML parser
+│   └── server-schema.ts           → Worker IPC message schema
+│
+├── k8s/                           ← Kubernetes manifests
+│   ├── configmap.yaml
+│   ├── tls-secret.yaml
+│   ├── proxy-deployment.yaml
+│   ├── proxy-service.yaml
+│   └── README.md
+│
+├── examples/                      ← Integration examples (NOT part of the proxy)
+│   ├── docker-compose/            ← Full demo stack (backend-a + backend-b)
+│   │   ├── server-template.js     → Minimal demo backend
+│   │   ├── Dockerfile.server      → Demo backend image
+│   │   ├── docker-compose.yml     → Full demo stack
+│   │   ├── config.yaml            → Demo config
+│   │   └── README.md
+│   └── express/                   ← Express.js integration example
+│       ├── server.js
+│       └── README.md
+│
+├── Dockerfile                     ← Proxy image (multi-stage build)
+├── Jenkinsfile                    ← CI/CD declarative pipeline
+├── sonar-project.properties       ← SonarQube config
+├── docker-compose.yml             ← Proxy + Redis only
+├── config.example.yaml            ← Fully commented configuration template
+├── .dockerignore
+├── .gitignore
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+---
+
+## Tech Stack
+
+| Technology | Purpose |
+|---|---|
+| TypeScript | Full type safety |
+| Node.js Cluster | Master/Worker multi-process architecture |
+| Redis | Response caching |
+| Zod | Schema validation for config and worker messages |
+| YAML | Human-readable configuration |
+| Commander | CLI entry point |
+| Docker Compose | Orchestration |
+| Kubernetes | Production cluster deployment |
+| Jenkins | CI/CD pipeline |
+| SonarQube | Static code analysis |
+| Trivy | Container security scanning |
+
+---
+
+## Request Lifecycle
+
+```
+Client → :8080 HTTP → 301 redirect to HTTPS
+Client → :8443 HTTPS
+  1. Rate limiter checks client IP — 429 if exceeded
+  2. GET requests → Redis cache checked — HIT returns instantly
+  3. Write requests (POST/PUT/PATCH/DELETE) → cache invalidated
+  4. Request body assembled from chunks
+  5. Load balancer picks a healthy upstream
+  6. Worker process forwards request over keepAlive TCP
+  7. Upstream responds → reply sent back via IPC
+  8. Master sends response to client + caches (GET)
+  9. On failure → circuit breaker records it, retry up to 2 times
+```
+
+---
+
+## Performance Tips
+
+- Set `workers` to `nproc` — never exceed your CPU core count
+- Set `cache.enabled: true` for read-heavy APIs — reduces upstream load significantly
+- Keep `autoScaling.maxServers` realistic for your hardware (3–4 for a 4-core machine)
+- `keepAlive: true` is set by default — avoids TCP handshake overhead per request
+- Monitor `/__lb-stats` in production to see which upstreams are under load
+
+---
+
+## Contributing
+
+Pull requests are welcome. Please open an issue first to discuss significant changes.
+
+---
+
+## License
+
+MIT

package/config.example.yaml

@@ -0,0 +1,99 @@
+# ============================================================
+#  Ninja Reverse Proxy — Configuration Template
+# ============================================================
+#
+#  USAGE:
+#    Copy this file to config.yaml and edit it for your setup.
+#    cp config.example.yaml config.yaml
+#
+#  The proxy works with any HTTP backend — Express, Django,
+#  Spring Boot, FastAPI, Go, ASP.NET, Kubernetes Services, etc.
+# ============================================================
+
+server:
+
+  # ── Ports ──────────────────────────────────────────────────
+  listen: 8080          # HTTP port — all traffic redirected to HTTPS (301)
+  httpsPort: 8443       # HTTPS port — main entry point for all requests
+
+  # Number of worker processes to fork.
+  # Best practice: set this to the number of CPU cores (run `nproc`).
+  # Never exceed your core count — it causes context switching overhead.
+  workers: 2
+
+  # ── Load Balancing ─────────────────────────────────────────
+  loadBalancing:
+    strategy: round-robin       # Options: round-robin | least-connections | ip-hash | random
+    failureThreshold: 3         # Mark an upstream DOWN after this many consecutive failures
+    recoveryTimeMs: 15000       # Attempt to recover a DOWN upstream after this delay (ms)
+
+  # ── Redis Cache ────────────────────────────────────────────
+  #
+  # GET responses are cached. Write requests (POST/PUT/PATCH/DELETE)
+  # automatically invalidate the cache for that path.
+  #
+  cache:
+    enabled: false          # Set to true to enable Redis response caching
+    host: redis             # Redis hostname (use 'localhost' outside Docker)
+    port: 6379              # Redis port
+    ttlSeconds: 60          # Cache TTL — responses expire after this many seconds
+
+  # ── Upstream Backends ──────────────────────────────────────
+  #
+  # List every backend service this proxy should route traffic to.
+  # The proxy does not care what technology these services use.
+  #
+  # Examples:
+  #   - id: api-server
+  #     url: http://api-server:8000
+  #
+  #   - id: user-service
+  #     url: http://user-service:8080
+  #
+  #   - id: my-django-app
+  #     url: http://django:8000
+  #
+  #   - id: my-spring-boot
+  #     url: http://spring-boot:8080
+  #
+  upstreams:
+    - id: backend-a
+      url: http://backend-a:3001
+
+    - id: backend-b
+      url: http://backend-b:3002
+
+  # ── Path Routing Rules ─────────────────────────────────────
+  #
+  # Each path entry defines:
+  #   path      → URL prefix to match
+  #   upstream  → list of upstream IDs that serve this route
+  #   rateLimit → optional per-IP sliding window rate limit for this route
+  #
+  paths:
+    - path: /
+      upstream:
+        - backend-a
+        - backend-b
+      rateLimit:
+        windowMs: 60000       # 1-minute sliding window
+        maxRequests: 100000   # maximum requests per IP per window
+
+    - path: /api
+      upstream:
+        - backend-a
+        - backend-b
+      rateLimit:
+        windowMs: 60000
+        maxRequests: 50000
+
+  # ── Custom Request Headers ─────────────────────────────────
+  #
+  # Headers appended to every proxied request before forwarding upstream.
+  # 'client_ip' is a special value — replaced with the real client IP.
+  #
+  headers:
+    - key: X-Forwarded-For
+      value: client_ip
+    - key: X-Real-IP
+      value: client_ip

package/dist/Serviceregistry.d.ts

@@ -0,0 +1,31 @@
+export interface ServiceInstance {
+    id: string;
+    url: string;
+    registeredAt: number;
+    lastHeartbeat: number;
+    status: 'UP' | 'DOWN';
+    metadata?: Record<string, string>;
+}
+export interface RegistryConfig {
+    heartbeatTimeoutMs?: number;
+    cleanupIntervalMs?: number;
+}
+export declare class ServiceRegistry {
+    private services;
+    private heartbeatTimeoutMs;
+    private onRegisterCallbacks;
+    private onDeregisterCallbacks;
+    constructor(config: RegistryConfig);
+    register(instance: Omit<ServiceInstance, 'registeredAt' | 'lastHeartbeat' | 'status'>): ServiceInstance;
+    deregister(id: string): boolean;
+    heartbeat(id: string): boolean;
+    getHealthy(): ServiceInstance[];
+    getAll(): ServiceInstance[];
+    get(id: string): ServiceInstance | undefined;
+    private checkHeartbeats;
+    onRegister(cb: (service: ServiceInstance) => void): void;
+    onDeregister(cb: (service: ServiceInstance) => void): void;
+    getStats(): object;
+}
+export declare const registry: ServiceRegistry;
+//# sourceMappingURL=Serviceregistry.d.ts.map

package/dist/Serviceregistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Serviceregistry.d.ts","sourceRoot":"","sources":["../src/Serviceregistry.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,cAAc;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAA2C;IAC3D,OAAO,CAAC,kBAAkB,CAAS;IAEnC,OAAO,CAAC,mBAAmB,CAA8C;IACzE,OAAO,CAAC,qBAAqB,CAA8C;gBAE/D,MAAM,EAAE,cAAc;IAMlC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,cAAc,GAAG,eAAe,GAAG,QAAQ,CAAC,GAAG,eAAe;IAavG,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAW/B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAU9B,UAAU,IAAI,eAAe,EAAE;IAG/B,MAAM,IAAI,eAAe,EAAE;IAI3B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI5C,OAAO,CAAC,eAAe;IAcvB,UAAU,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI;IAIxD,YAAY,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,GAAG,IAAI;IAG1D,QAAQ,IAAI,MAAM;CAcnB;AACD,eAAO,MAAM,QAAQ,iBAGnB,CAAA"}

package/dist/Serviceregistry.js

@@ -0,0 +1,95 @@
+export class ServiceRegistry {
+    services = new Map();
+    heartbeatTimeoutMs;
+    // on every registry of a function 
+    onRegisterCallbacks = [];
+    onDeregisterCallbacks = [];
+    constructor(config) {
+        this.heartbeatTimeoutMs = config.heartbeatTimeoutMs ?? 30_000;
+        setInterval(() => {
+            this.checkHeartbeats();
+        }, config.cleanupIntervalMs ?? 10_000);
+    }
+    register(instance) {
+        const service = {
+            ...instance,
+            registeredAt: Date.now(),
+            lastHeartbeat: Date.now(),
+            // mark the incoming server to UP 
+            status: 'UP',
+        };
+        this.services.set(instance.id, service);
+        console.log(`[Registry] Service REGISTERED: ${instance.id} → ${instance.url}`);
+        this.onRegisterCallbacks.forEach(callback => callback(service));
+        return service;
+    }
+    deregister(id) {
+        const service = this.services.get(id);
+        if (!service) {
+            return false;
+        }
+        service.status = 'DOWN';
+        this.services.delete(id);
+        console.log(`[Registry] Service DEREGISTERED: ${id}`);
+        this.onDeregisterCallbacks.forEach(callback => callback(service));
+        return true;
+    }
+    heartbeat(id) {
+        const service = this.services.get(id);
+        if (!service) {
+            return false;
+        }
+        service.lastHeartbeat = Date.now();
+        service.status = 'UP';
+        return true;
+    }
+    // to get all up services
+    getHealthy() {
+        return [...this.services.values()].filter(s => s.status === 'UP');
+    }
+    getAll() {
+        return [...this.services.values()];
+    }
+    // get single service 
+    get(id) {
+        return this.services.get(id);
+    }
+    // to check heartbeat is consistent or not 
+    checkHeartbeats() {
+        const now = Date.now();
+        for (const [id, service] of this.services) {
+            if (service.metadata?.dynamic === "true" &&
+                service.status === 'UP' &&
+                now - service.lastHeartbeat > this.heartbeatTimeoutMs) {
+                console.log(`[Registry] Service TIMED OUT (no heartbeat): ${id}`);
+                service.status = 'DOWN';
+                this.onDeregisterCallbacks.forEach(callback => callback(service));
+            }
+        }
+    }
+    onRegister(cb) {
+        this.onRegisterCallbacks.push(cb);
+    }
+    onDeregister(cb) {
+        this.onDeregisterCallbacks.push(cb);
+    }
+    getStats() {
+        return {
+            total: this.services.size,
+            healthy: this.getHealthy().length,
+            services: this.getAll().map(s => ({
+                id: s.id,
+                url: s.url,
+                status: s.status,
+                uptime: `${Math.floor((Date.now() - s.registeredAt) / 1000)}s`,
+                lastHeartbeat: `${Math.floor((Date.now() - s.lastHeartbeat) / 1000)}s ago`,
+                metadata: s.metadata,
+            })),
+        };
+    }
+}
+export const registry = new ServiceRegistry({
+    heartbeatTimeoutMs: 30_000,
+    cleanupIntervalMs: 10_000
+});
+//# sourceMappingURL=Serviceregistry.js.map