@onlineapps/conn-orch-registry 2.0.2 → 3.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/conn-orch-registry",
-  "version": "2.0.2",
+  "version": "3.0.1",
   "license": "MIT",
   "description": "Connector-registry-client provides the core communication mechanism for microservices in this environment. It enables them to interact with a services_registry to receive and fulfill tasks by submitting heartbeats or their API descriptions.",
   "keywords": [
@@ -48,10 +48,6 @@
     "@semantic-release/npm": "^11.0.3",
     "@semantic-release/release-notes-generator": "^12.1.0",
     "eslint": "^8.44.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-import": "^2.30.1",
-    "eslint-plugin-prettier": "^5.4.0",
     "ioredis": "^5.8.0",
     "jest": "^29.6.1",
     "semantic-release": "^22.0.12"

package/src/defaults.js

@@ -9,6 +9,10 @@
  */
 
 module.exports = {
+  // Key prefix the registry builds its Redis keys with (its own
+  // REDIS_REGISTRY_KEY_PREFIX). Module-owned default, overridable per instance —
+  // never a literal inside a method (architecture-principles §2).
+  registryKeyPrefix: 'registry:',
   // `specificationEndpoint`, `specProtocol` and `specHost` lived here until
   // 2026-08-29. Their only reader was src/config.js, whose only readers were its
   // own tests — a declaration nothing runtime read, which forced every

package/src/registryClient.js

@@ -50,6 +50,7 @@ class ServiceRegistryClient extends EventEmitter {
   constructor({ amqpUrl, serviceName, version, specificationEndpoint = '/api/v1/specification',
                 heartbeatInterval = 10000, apiQueue = 'api_services_queuer', registryQueue = 'registry.register',
                 registryUrl = null, redis = null, storageConfig = {}, validationProof = null,
+                registryKeyPrefix = DEFAULTS.registryKeyPrefix,
                 registrationTimeoutMs = DEFAULTS.registrationTimeoutMs }) {
     super();
     if (!amqpUrl || !serviceName || !version) {
@@ -77,6 +78,7 @@ class ServiceRegistryClient extends EventEmitter {
     // Event consumer (optional, activated via subscribeToChanges)
     this.eventConsumer = null;
     this.redis = redis;
+    this.registryKeyPrefix = registryKeyPrefix;
     this.storageConfig = storageConfig;
 
     // Validation proof (injected via constructor - DEPENDENCY INJECTION)
@@ -712,49 +714,63 @@ class ServiceRegistryClient extends EventEmitter {
   /**
    * Get basic service state for service discovery.
    *
-   * cookbook-router expects `registryClient.getService(serviceName)` to exist and
-   * return an object with `status`. RegistryEventConsumer stores status as
-   * 'ACTIVE'/'INACTIVE' (uppercase), so we normalize to lowercase.
+   * Reads the projection the registry already maintains — the `<prefix>services`
+   * hash, one JSON summary per service name. **Not HTTP.** The owner decided that
+   * on 2026-09-02 (confirmation biz-discovery-redis-001). It is its own decision,
+   * not a reading of ADR 0005: that ADR
+   * (api/docs/biz/80-decisions/0005-no-http-in-biz-containers.md) bans an HTTP
+   * LISTENER in a biz container and is silent on outbound calls — this extends the
+   * same reasoning to the calls a biz container makes.
+   * Until then this method polled `GET /services`, which is what made every biz
+   * container an HTTP client of the registry ~142x a day.
+   *
+   * There is deliberately no HTTP fallback. A missing Redis client is a wiring
+   * error and says so (architecture-principles §3, §4) — falling back would
+   * restore the very traffic this change removes, and hide the misconfiguration.
+   *
+   * cookbook-router expects `{ status }`; the registry writes it lowercase
+   * ('active'/'inactive') into the summary, so no normalization happens here.
    *
    * @param {string} serviceName
-   * @returns {Promise<{serviceName: string, status: 'active'|'inactive', version?: string, fingerprint?: string, bucket?: string, path?: string, updatedAt?: string} | null>}
+   * @returns {Promise<{serviceName: string, status: string, version?: string, lastHeartbeatAt?: string} | null>}
    */
   async getService(serviceName) {
     if (!serviceName || typeof serviceName !== 'string') {
       throw new Error('[RegistryClient] getService - serviceName is required and must be a string');
     }
 
-    if (!this.registryUrl || typeof this.registryUrl !== 'string') {
-      throw new Error('[RegistryClient] getService - Missing required config: registryUrl. Fix: pass wrapper.registry.url into ServiceRegistryClient.');
-    }
-
-    // Primary source of truth for service availability is the central registry HTTP API.
-    // This avoids relying on optional event subscriptions and ensures deterministic routing.
-    const url = `${this.registryUrl.replace(/\/$/, '')}/services`;
-    let response;
-    try {
-      response = await fetch(url, { method: 'GET' });
-    } catch (err) {
-      throw new Error(`[RegistryClient] getService - Registry HTTP request failed (${url}). Problem: ${err.message}`);
+    if (!this.redis || typeof this.redis.hGet !== 'function') {
+      throw new Error(
+        '[RegistryClient] getService - Missing Redis client for service discovery. '
+        + 'Expected/Fix: pass `redis` (a connected client exposing hGet) into the '
+        + 'ServiceRegistryClient constructor; @onlineapps/service-wrapper does this '
+        + 'from its own Redis configuration. Discovery reads the registry projection, '
+        + 'never HTTP (owner decision biz-discovery-redis-001, 2026-09-02).'
+      );
     }
 
-    if (!response.ok) {
-      throw new Error(`[RegistryClient] getService - Registry HTTP request failed (${url}). Status: ${response.status}`);
+    const key = `${this.registryKeyPrefix}services`;
+    const raw = await this.redis.hGet(key, serviceName);
+    if (!raw) {
+      return null;
     }
 
-    const data = await response.json();
-    const entry = data && data.services ? data.services[serviceName] : null;
-    if (!entry) {
-      return null;
+    let entry;
+    try {
+      entry = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `[RegistryClient] getService - Registry projection entry for "${serviceName}" is not valid JSON `
+        + `(key ${key}). Problem: ${err.message}. Fix: the registry owns this value; `
+        + 'a corrupt entry is a registry-side defect, not something a caller may guess around.'
+      );
     }
 
-    // Registry stores status as 'active'/'inactive' (lowercase).
     return {
       serviceName,
       status: entry.status,
       version: entry.version,
-      lastHeartbeatAt: entry.lastHeartbeatAt,
-      isAvailable: entry.isAvailable
+      lastHeartbeatAt: entry.lastHeartbeatAt
     };
   }