@onlineapps/service-wrapper 2.1.41 → 2.1.43

package/config/runtime-defaults.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "description": "Runtime defaults for @onlineapps/service-wrapper (non-critical only). Service configs may override.",
+  "defaults": {
+    "wrapper": {
+      "mq": {
+        "prefetch": 10,
+        "enabled": true
+      },
+      "registry": {
+        "enabled": true,
+        "heartbeatInterval": 30000
+      },
+      "infrastructureGate": {
+        "maxWaitMs": 300000,
+        "checkIntervalMs": 5000
+      },
+      "infrastructureVerify": {
+        "maxRetries": 12,
+        "baseDelayMs": 5000,
+        "maxDelayMs": 30000,
+        "queueCheckTimeoutMs": 5000
+      },
+      "monitoring": {
+        "enabled": true,
+        "metrics": ["requests", "errors", "duration"]
+      },
+      "logging": {
+        "enabled": true,
+        "level": "info",
+        "requests": {
+          "enabled": true,
+          "bodies": true,
+          "headers": false
+        },
+        "responses": {
+          "enabled": true,
+          "bodies": true
+        },
+        "excludePaths": ["/health", "/status", "/metrics", "/specification"]
+      },
+      "health": {
+        "enabled": true,
+        "endpoint": "/health"
+      },
+      "validation": {
+        "enabled": true
+      }
+    }
+  }
+}
+
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.1.41",
+  "version": "2.1.43",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {

package/src/ConfigLoader.js

@@ -22,6 +22,8 @@
 const fs = require('fs');
 const path = require('path');
 
+const RUNTIME_DEFAULTS = require('../config/runtime-defaults.json');
+
 /**
  * CENTRAL REGISTRY: All configuration files used by business services
  * If you add a new config file, add it here!
@@ -47,7 +49,7 @@ const CONFIG_REGISTRY = {
 class ConfigLoader {
   /**
    * Resolve environment variable substitution
-   * Supports format: ${VAR_NAME:default_value}
+   * Supports format: ${VAR_NAME:default_value} OR ${VAR_NAME}
    * @param {string} value - Value to resolve
    * @returns {string} Resolved value
    */
@@ -65,7 +67,104 @@ class ConfigLoader {
     const varName = match[1];
     const defaultValue = match[2];
 
-    return process.env[varName] || defaultValue || '';
+    const envValue = process.env[varName];
+    if (envValue !== undefined) {
+      return envValue;
+    }
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    throw new Error(`[ConfigLoader] Missing environment variable - ${varName} is required (config placeholder ${match[0]})`);
+  }
+
+  /**
+   * Apply ${VAR} / ${VAR:default} substitutions anywhere within a string.
+   * Mirrors ServiceWrapper placeholder support but keeps logic centralized in ConfigLoader.
+   *
+   * NOTE: This does NOT enforce strict missing-env behavior (that is addressed later).
+   *
+   * @param {string} value
+   * @returns {string}
+   */
+  static resolveEnvPlaceholdersInString(value) {
+    if (typeof value !== 'string') {
+      return value;
+    }
+
+    return value.replace(/\$\{([^:}]+)(?::([^}]*))?\}/g, (match, varName, defaultValue) => {
+      const envValue = process.env[varName];
+
+      // Use env value if exists (even if empty string)
+      if (envValue !== undefined) {
+        return envValue;
+      }
+
+      // Use default if provided
+      if (defaultValue !== undefined) {
+        return defaultValue;
+      }
+
+      // Fail-fast: placeholder without default requires ENV to be set
+      throw new Error(`[ConfigLoader] Missing environment variable - ${varName} is required (config placeholder ${match})`);
+    });
+  }
+
+  /**
+   * Deeply resolve env placeholders across an object.
+   * @param {any} input
+   * @param {Object} [options]
+   * @param {string} [options.jsonPath] - JSON path prefix for error context
+   * @returns {any}
+   */
+  static resolveEnvPlaceholdersDeep(input, options = {}) {
+    const { jsonPath = '$' } = options;
+
+    if (Array.isArray(input)) {
+      return input.map((item, idx) => this.resolveEnvPlaceholdersDeep(item, { jsonPath: `${jsonPath}[${idx}]` }));
+    }
+
+    if (input && typeof input === 'object') {
+      const out = {};
+      for (const [k, v] of Object.entries(input)) {
+        out[k] = this.resolveEnvPlaceholdersDeep(v, { jsonPath: `${jsonPath}.${k}` });
+      }
+      return out;
+    }
+
+    if (typeof input === 'string') {
+      try {
+        return this.resolveEnvPlaceholdersInString(input);
+      } catch (err) {
+        throw new Error(`${err.message} at ${jsonPath}`);
+      }
+    }
+
+    return input;
+  }
+
+  /**
+   * Deep merge (plain objects only). Arrays are replaced (not merged).
+   * @param {Object} base
+   * @param {Object} override
+   * @returns {Object}
+   */
+  static deepMerge(base, override) {
+    if (!base || typeof base !== 'object' || Array.isArray(base)) {
+      return override;
+    }
+    if (!override || typeof override !== 'object' || Array.isArray(override)) {
+      return override === undefined ? base : override;
+    }
+
+    const out = { ...base };
+    for (const [k, v] of Object.entries(override)) {
+      if (v && typeof v === 'object' && !Array.isArray(v) && base[k] && typeof base[k] === 'object' && !Array.isArray(base[k])) {
+        out[k] = this.deepMerge(base[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+    return out;
   }
 
   /**
@@ -115,7 +214,16 @@ class ConfigLoader {
       // Always use version from package.json (Single Source of Truth)
       config.service.version = this.loadPackageVersion(basePath);
 
-      return config;
+      // Apply repo defaults (non-critical) then allow service config to override
+      const defaults = RUNTIME_DEFAULTS?.defaults || {};
+      const merged = this.deepMerge(defaults, config);
+
+      // Resolve env placeholders across the whole config (service + wrapper + custom sections)
+      try {
+        return this.resolveEnvPlaceholdersDeep(merged, { jsonPath: '$' });
+      } catch (err) {
+        throw new Error(`[ConfigLoader] Failed to resolve placeholders in ${configPath}. ${err.message}`);
+      }
     } catch (error) {
       if (error.code === 'ENOENT') {
         throw new Error(`Service config not found: ${configPath}`);
@@ -195,21 +303,28 @@ class ConfigLoader {
     const operations = this.loadOperations(basePath);
     const validationProof = this.loadValidationProof(basePath);
 
-    // Resolve environment variables in port and url
-    const resolvedPort = this.resolveEnvVar(serviceConfig.service.port);
-    const resolvedUrl = this.resolveEnvVar(serviceConfig.service.url);
+    // Include any custom top-level sections from config.json (e.g., storage, smtp, etc.)
+    // Keep service-wrapper owned sections (service, wrapper) explicit and stable.
+    const customSections = {};
+    for (const [k, v] of Object.entries(serviceConfig || {})) {
+      if (k === 'service' || k === 'wrapper') {
+        continue;
+      }
+      customSections[k] = v;
+    }
 
     return {
       service: {
         name: serviceConfig.service.name,
         version: serviceConfig.service.version,
-        port: parseInt(resolvedPort, 10),
-        url: resolvedUrl,
-        env: process.env.NODE_ENV || 'development'
+        port: parseInt(serviceConfig.service.port, 10),
+        url: serviceConfig.service.url,
+        env: process.env.NODE_ENV
       },
       wrapper: serviceConfig.wrapper || {},
       operations,
-      validationProof
+      validationProof,
+      ...customSections
     };
   }
 

package/src/ServiceWrapper.js

@@ -156,8 +156,15 @@ class ServiceWrapper {
     const { waitForInfrastructureReady } = require('@onlineapps/service-common');
     const { requireEnv } = require('@onlineapps/service-common');
     const redisUrl = this.config.wrapper?.cache?.url || requireEnv('REDIS_URL', 'Redis connection URL');
-    const maxWait = parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME) || 300000;
-    const checkInterval = parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL) || 5000;
+    const maxWait = this.config.wrapper?.infrastructureGate?.maxWaitMs;
+    const checkInterval = this.config.wrapper?.infrastructureGate?.checkIntervalMs;
+
+    if (typeof maxWait !== 'number' || Number.isNaN(maxWait) || maxWait <= 0) {
+      throw new Error(`[InfrastructureGate] Invalid configuration - wrapper.infrastructureGate.maxWaitMs must be a positive number, got: ${maxWait}`);
+    }
+    if (typeof checkInterval !== 'number' || Number.isNaN(checkInterval) || checkInterval <= 0) {
+      throw new Error(`[InfrastructureGate] Invalid configuration - wrapper.infrastructureGate.checkIntervalMs must be a positive number, got: ${checkInterval}`);
+    }
 
     const logWithPrefix = (level, message) => {
       const prefixed = `[InfrastructureGate:${context}] ${message}`;
@@ -238,9 +245,8 @@ class ServiceWrapper {
             return defaultValue;
           }
 
-          // Log warning and return empty string
-          console.warn(`[ServiceWrapper] Missing env variable: ${varName}`);
-          return '';
+          // Fail-fast: placeholder without default requires ENV to be set
+          throw new Error(`[ServiceWrapper] Missing environment variable - ${varName} is required (config placeholder ${match})`);
         });
       }
       return value;
@@ -794,9 +800,25 @@ class ServiceWrapper {
       throw new Error('Registry URL is required when registry is enabled. Set wrapper.registry.url in config');
     }
 
-    const serviceName = this.config.service?.name || 'unnamed-service';
-    const servicePort = this.config.service?.port || process.env.PORT || 3000;
-    const mqUrl = this.config.wrapper?.mq?.url || '';
+    const serviceName = this.config.service?.name;
+    if (!serviceName) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.name is required');
+    }
+
+    const servicePort = this.config.service?.port;
+    if (!servicePort) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.port is required');
+    }
+
+    const serviceUrl = this.config.service?.url;
+    if (!serviceUrl) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.url is required');
+    }
+
+    const mqUrl = this.config.wrapper?.mq?.url;
+    if (!mqUrl) {
+      throw new Error('[ServiceWrapper] Missing configuration - wrapper.mq.url is required');
+    }
 
     // Infrastructure health check was already done in Fáze 0.4
     // FÁZE 0.5 a 0.6: Vytvoření front a spuštění konzumerů se provádí v registryClient.init()
@@ -805,7 +827,7 @@ class ServiceWrapper {
     this.registryClient = new RegistryConnector.ServiceRegistryClient({
       amqpUrl: mqUrl,
       serviceName: serviceName,
-      version: this.config.service?.version || '1.0.0',
+      version: this.config.service?.version,
       registryQueue: 'registry.register', // Use correct queue name
       registryUrl: registryUrl,
       logger: this.logger || console,
@@ -819,10 +841,10 @@ class ServiceWrapper {
     // Register service
     const serviceInfo = {
       name: serviceName,
-      url: `http://localhost:${servicePort}`,
+      url: serviceUrl,
       operations: this.operations?.operations || {},
       metadata: {
-        version: this.config.service?.version || '1.0.0',
+        version: this.config.service?.version,
         description: this.config.service?.description || ''
       }
     };
@@ -888,10 +910,10 @@ class ServiceWrapper {
     }
 
     // Start heartbeat
-    // Priority: ENV variable > config > default (10s)
-    const heartbeatInterval = parseInt(process.env.HEARTBEAT_INTERVAL) ||
-                               this.config.wrapper?.registry?.heartbeatInterval ||
-                               10000;
+    const heartbeatInterval = this.config.wrapper?.registry?.heartbeatInterval;
+    if (typeof heartbeatInterval !== 'number' || Number.isNaN(heartbeatInterval) || heartbeatInterval <= 0) {
+      throw new Error(`[ServiceWrapper] Invalid configuration - wrapper.registry.heartbeatInterval must be a positive number, got: ${heartbeatInterval}`);
+    }
     this.logger?.info(`[ServiceWrapper] Heartbeat interval set to ${heartbeatInterval}ms`);
 
     this.heartbeatTimer = setInterval(async () => {
@@ -920,9 +942,23 @@ class ServiceWrapper {
    * @private
    */
   async _verifyInfrastructureReady(serviceName) {
-    const maxRetries = parseInt(process.env.INFRASTRUCTURE_VERIFY_MAX_RETRIES) || 12; // 12 * 5s = 60s max
-    const baseDelay = parseInt(process.env.INFRASTRUCTURE_VERIFY_BASE_DELAY) || 5000; // 5 seconds
-    const maxDelay = parseInt(process.env.INFRASTRUCTURE_VERIFY_MAX_DELAY) || 30000; // 30 seconds max
+    const maxRetries = this.config.wrapper?.infrastructureVerify?.maxRetries;
+    const baseDelay = this.config.wrapper?.infrastructureVerify?.baseDelayMs;
+    const maxDelay = this.config.wrapper?.infrastructureVerify?.maxDelayMs;
+    const queueCheckTimeoutMs = this.config.wrapper?.infrastructureVerify?.queueCheckTimeoutMs;
+
+    if (typeof maxRetries !== 'number' || Number.isNaN(maxRetries) || maxRetries <= 0) {
+      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.maxRetries must be a positive number, got: ${maxRetries}`);
+    }
+    if (typeof baseDelay !== 'number' || Number.isNaN(baseDelay) || baseDelay <= 0) {
+      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.baseDelayMs must be a positive number, got: ${baseDelay}`);
+    }
+    if (typeof maxDelay !== 'number' || Number.isNaN(maxDelay) || maxDelay <= 0) {
+      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.maxDelayMs must be a positive number, got: ${maxDelay}`);
+    }
+    if (typeof queueCheckTimeoutMs !== 'number' || Number.isNaN(queueCheckTimeoutMs) || queueCheckTimeoutMs <= 0) {
+      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.queueCheckTimeoutMs must be a positive number, got: ${queueCheckTimeoutMs}`);
+    }
     
     // Required infrastructure queues that must exist before business queues can be created
     const requiredInfrastructureQueues = [
@@ -962,15 +998,14 @@ class ServiceWrapper {
         }
         
         const missingQueues = [];
-        const QUEUE_CHECK_TIMEOUT = 5000; // 5 seconds per queue check
         for (const queueName of requiredInfrastructureQueues) {
           try {
             // Add timeout to prevent hanging on checkQueue
             const checkPromise = channel.checkQueue(queueName);
             const checkTimeoutPromise = new Promise((_, reject) => {
               setTimeout(() => {
-                reject(new Error(`checkQueue timeout after ${QUEUE_CHECK_TIMEOUT}ms`));
-              }, QUEUE_CHECK_TIMEOUT);
+                reject(new Error(`checkQueue timeout after ${queueCheckTimeoutMs}ms`));
+              }, queueCheckTimeoutMs);
             });
             
             await Promise.race([checkPromise, checkTimeoutPromise]);
@@ -1004,7 +1039,7 @@ class ServiceWrapper {
           try {
             const checkPromise = channel.checkQueue(queueName);
             const checkTimeoutPromise = new Promise((_, reject) => {
-              setTimeout(() => reject(new Error('timeout')), QUEUE_CHECK_TIMEOUT);
+              setTimeout(() => reject(new Error('timeout')), queueCheckTimeoutMs);
             });
             await Promise.race([checkPromise, checkTimeoutPromise]);
             this.logger?.info(`[InfrastructureVerify] ✓ Optional queue exists: ${queueName}`);
@@ -1102,14 +1137,29 @@ class ServiceWrapper {
    * @private
    */
   async _initializeOrchestrator() {
-    const servicePort = this.config.service?.port || process.env.PORT || 3000;
-    const serviceUrl = `http://localhost:${servicePort}`;
+    const serviceName = this.config.service?.name;
+    const serviceVersion = this.config.service?.version;
+    const environment = this.config.service?.env;
+    const serviceUrl = this.config.service?.url;
+
+    if (!serviceName) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.name is required');
+    }
+    if (!serviceVersion) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.version is required');
+    }
+    if (!environment) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.env (NODE_ENV) is required');
+    }
+    if (!serviceUrl) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.url is required');
+    }
 
     // Create error handler with monitoring instance
     const errorHandler = new ErrorHandlerConnector({
-      serviceName: this.config.service?.name || 'unnamed-service',
-      serviceVersion: this.config.service?.version || '0.0.0',
-      environment: process.env.NODE_ENV || 'development',
+      serviceName,
+      serviceVersion,
+      environment,
       monitoring: this.monitoring,  // Use monitoring instance from conn-base-monitoring
       handling: {
         maxRetries: this.config.wrapper?.errorHandling?.maxRetries || 3,
@@ -1374,8 +1424,12 @@ class ServiceWrapper {
       throw new Error(`Unknown operation: ${operationName}`);
     }
 
-    const servicePort = this.config.service?.port || process.env.PORT || 3000;
-    const url = `http://localhost:${servicePort}${operation.endpoint}`;
+    const serviceUrl = this.config.service?.url;
+    if (!serviceUrl) {
+      throw new Error('[ServiceWrapper] Missing configuration - service.url is required');
+    }
+
+    const url = new URL(operation.endpoint, serviceUrl).toString();
     const method = operation.method || 'POST';
 
     this.logger?.debug(`Executing operation ${operationName} via ${method} ${url}`);
@@ -1386,10 +1440,15 @@ class ServiceWrapper {
     return new Promise((resolve, reject) => {
       const postData = JSON.stringify(input);
 
+      const target = new URL(url);
+      const targetPort = target.port
+        ? parseInt(target.port, 10)
+        : (target.protocol === 'https:' ? 443 : 80);
+
       const options = {
-        hostname: 'localhost',
-        port: servicePort,
-        path: operation.endpoint,
+        hostname: target.hostname,
+        port: targetPort,
+        path: `${target.pathname}${target.search}`,
         method: method,
         headers: {
           'Content-Type': 'application/json',

package/src/index.js

@@ -63,7 +63,7 @@ async function bootstrap(serviceRoot, options = {}) {
   const PORT = config.service.port;
   const server = app.listen(PORT, () => {
     console.log(`✓ HTTP server listening on port ${PORT}`);
-    console.log(`✓ Health check: http://localhost:${PORT}/health`);
+    console.log(`✓ Health check: /health`);
   });
 
   // 2. Initialize Service Wrapper (MQ, Registry, Monitoring, etc.)
@@ -76,7 +76,7 @@ async function bootstrap(serviceRoot, options = {}) {
         name: config.service.name,
         version: config.service.version,
         port: config.service.port,
-        url: process.env.SERVICE_URL || `http://localhost:${PORT}`
+        url: config.service.url
       },
       wrapper: config.wrapper
     },