@onlineapps/service-wrapper 2.1.42 → 2.1.43

package/config/runtime-defaults.json

@@ -11,6 +11,16 @@
         "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"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.1.42",
+  "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

@@ -67,7 +67,14 @@ 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]})`);
   }
 
   /**
@@ -296,17 +303,28 @@ class ConfigLoader {
     const operations = this.loadOperations(basePath);
     const validationProof = this.loadValidationProof(basePath);
 
+    // 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(serviceConfig.service.port, 10),
         url: serviceConfig.service.url,
-        env: process.env.NODE_ENV || 'development'
+        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
     },