@onlineapps/service-wrapper 2.1.118 → 2.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.1.118",
+  "version": "2.2.1",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -32,7 +32,7 @@
     "@onlineapps/conn-orch-cookbook": "2.0.35",
     "@onlineapps/conn-orch-orchestrator": "1.0.103",
     "@onlineapps/conn-orch-registry": "1.1.52",
-    "@onlineapps/conn-orch-validator": "2.0.30",
+    "@onlineapps/conn-orch-validator": "2.0.31",
     "@onlineapps/monitoring-core": "1.0.21",
     "@onlineapps/service-common": "1.0.17",
     "@onlineapps/runtime-config": "1.0.2"

package/src/ServiceWrapper.js

@@ -483,6 +483,15 @@ class ServiceWrapper {
       // Konfigurace se načítá v konstruktoru, takže tady jen logujeme
       this._logPhase('0.1', 'Configuration Load', 'PASSED', null, Date.now() - startTime);
 
+      // FÁZE 0.1b: Operations-Routes alignment validation
+      const alignmentStartTime = Date.now();
+      try {
+        this._validateOperationsRouteAlignment();
+        this._logPhase('0.1b', 'Operations-Routes Alignment', 'PASSED', null, Date.now() - alignmentStartTime);
+      } catch (error) {
+        this._handleInitializationError('0.1b', 'Operations-Routes Alignment', error, false);
+      }
+
       // FÁZE 0.2: Tier 1 validace (PŘED MQ připojením)
       if (this.serviceRoot && this.config.wrapper?.validation?.enabled !== false) {
         const validationStartTime = Date.now();
@@ -1642,6 +1651,119 @@ class ServiceWrapper {
     });
   }
 
+  /**
+   * Extract all registered Express routes from the app router stack.
+   * Handles nested Router instances (e.g. app.use('/api', router)).
+   * Compatible with Express 4 (app._router) and Express 5 (app.router).
+   * @private
+   * @returns {Array<{method: string, path: string}>}
+   */
+  _extractExpressRoutes() {
+    const routes = [];
+    const stack = this.app._router?.stack || this.app.router?.stack || [];
+
+    const extractFromStack = (layers, prefix) => {
+      for (const layer of layers) {
+        if (layer.route) {
+          for (const method of Object.keys(layer.route.methods)) {
+            routes.push({ method: method.toUpperCase(), path: `${prefix}${layer.route.path}` });
+          }
+        } else if (layer.name === 'router' && layer.handle?.stack) {
+          let mountPath = '';
+
+          // Express 4: extract prefix from regexp
+          if (layer.regexp?.source) {
+            const match = layer.regexp.source.match(/^\^\\\/([a-zA-Z0-9_/-]+)/);
+            if (match) mountPath = `/${match[1]}`;
+          }
+
+          // Express 5: probe the matcher to discover mount prefix
+          if (!mountPath && layer.matchers?.[0]) {
+            const probe = layer.matchers[0]('/api');
+            if (probe && probe.path) mountPath = probe.path;
+          }
+
+          extractFromStack(layer.handle.stack, `${prefix}${mountPath}`);
+        }
+      }
+    };
+
+    extractFromStack(stack, '');
+    return routes;
+  }
+
+  /**
+   * Bidirectional validation: operations.json <-> Express routes.
+   * Check A: every declared operation has a matching Express route.
+   * Check B: every /api/* route has a matching operation or is in _internal.
+   * @private
+   * @throws {Error} Permanent error listing all mismatches
+   */
+  _validateOperationsRouteAlignment() {
+    const ops = this.operations?.operations || {};
+    const internalEntries = this.operations?._internal || [];
+    const expressRoutes = this._extractExpressRoutes();
+
+    const routeSet = new Set(
+      expressRoutes.map(r => `${r.method}:${r.path}`)
+    );
+
+    const errors = [];
+
+    // Check A: every operation endpoint+method must exist as an Express route
+    for (const [opName, opDef] of Object.entries(ops)) {
+      const method = (opDef.method || 'POST').toUpperCase();
+      const endpoint = opDef.endpoint;
+      if (!endpoint) continue;
+
+      if (!routeSet.has(`${method}:${endpoint}`)) {
+        errors.push(`Operation '${opName}' endpoint ${method} ${endpoint} not found in Express routes`);
+      }
+    }
+
+    // Build lookup: endpoint -> set of operation methods
+    const opEndpoints = new Map();
+    for (const opDef of Object.values(ops)) {
+      const method = (opDef.method || 'POST').toUpperCase();
+      const endpoint = opDef.endpoint;
+      if (!endpoint) continue;
+      if (!opEndpoints.has(endpoint)) opEndpoints.set(endpoint, new Set());
+      opEndpoints.get(endpoint).add(method);
+    }
+
+    // Build _internal lookup
+    const internalSet = new Set(
+      internalEntries.map(e => `${(e.method || 'GET').toUpperCase()}:${e.endpoint}`)
+    );
+
+    // Check B: every /api/* route must have a matching operation or be _internal
+    for (const route of expressRoutes) {
+      if (!route.path.startsWith('/api')) continue;
+
+      const key = `${route.method}:${route.path}`;
+      if (internalSet.has(key)) continue;
+
+      const endpointOps = opEndpoints.get(route.path);
+      if (!endpointOps) {
+        errors.push(`Route ${route.method} ${route.path} has no matching operation in operations.json`);
+        continue;
+      }
+
+      if (!endpointOps.has(route.method)) {
+        // Tolerate GET alongside a declared POST (common browser-test pattern)
+        if (route.method === 'GET' && endpointOps.size > 0) continue;
+        errors.push(`Route ${route.method} ${route.path} has no matching operation in operations.json`);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(
+        `[ServiceWrapper] Operations-Routes alignment failed (${errors.length} issue${errors.length > 1 ? 's' : ''}):\n` +
+        errors.map(e => `  - ${e}`).join('\n')
+      );
+    }
+  }
+
   /**
    * Subscribe to infra.invalidation events on the infrastructure.health.events fanout exchange.
    * When received, deletes local validation proof and triggers re-validation with backoff.