@onlineapps/service-wrapper 2.1.5 → 2.1.10

package/package.json

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

package/src/ServiceWrapper.js

@@ -22,7 +22,6 @@ const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
 const CacheConnector = require('@onlineapps/conn-base-cache');
 const ErrorHandlerConnector = require('@onlineapps/conn-infra-error-handler');
 const { ValidationOrchestrator } = require('@onlineapps/conn-orch-validator');
-const { createHttpLogging } = require('./HttpLoggingMiddleware');
 
 const INFRA_QUEUE_OWNERS = {
   'workflow.init': 'Gateway (api_gateway)',
@@ -274,6 +273,7 @@ class ServiceWrapper {
    * @private
    */
   _logPhase(phase, phaseName, status, error = null, duration = null) {
+    const serviceName = this.config.service?.name || 'unnamed-service';
     const logMsg = `[FÁZE ${phase}] ${phaseName} - ${status}`;
     const logData = {
       phase,
@@ -282,8 +282,19 @@ class ServiceWrapper {
       timestamp: new Date().toISOString(),
       duration,
       error: error ? { message: error.message, stack: error.stack } : null,
-      serviceName: this.config.service?.name || 'unnamed-service'
+      serviceName
     };
+    
+    // Structured log for service wrapper phases
+    console.log(`[${serviceName}:service-wrapper:init:PHASE_${status}] ${JSON.stringify({
+      timestamp: new Date().toISOString(),
+      service: serviceName,
+      phase,
+      phase_name: phaseName,
+      status,
+      duration_ms: duration,
+      error: error ? error.message : null
+    })}`);
 
     if (status === 'PASSED') {
       this.logger?.info(logMsg, logData);
@@ -559,17 +570,9 @@ class ServiceWrapper {
     // Logger is now available, use it
     this.logger.info('Monitoring connector initialized', { logsDir });
 
-    // Apply HTTP logging middleware (configurable via wrapper.logging)
-    if (this.app) {
-      const loggingConfig = this.config.wrapper?.logging || {};
-      const httpLogging = createHttpLogging(() => this.logger, loggingConfig);
-      
-      // Store for access from outside if needed
-      this.httpLogging = httpLogging;
-      
-      // Apply middlewares to Express app
-      httpLogging.applyTo(this.app);
-    }
+    // NOTE: HTTP logging middleware is applied directly in service's app.js
+    // using middlewares/httpLogging.js with lazy logger access via lib/logger.js
+    // Configuration is in conn-config/config.json -> wrapper.logging (for reference)
   }
 
   /**
@@ -1264,10 +1267,13 @@ class ServiceWrapper {
         }
         
         // Normalize message format: Gateway sends workflowId, orchestrator expects workflow_id
+        // V2 format uses step_id, V1 used id - support both for backwards compatibility during migration
+        const firstStep = message.cookbook?.steps?.[0];
+        const firstStepId = firstStep?.step_id || firstStep?.id;
         const normalizedMessage = {
           ...message,
           workflow_id: message.workflow_id || message.workflowId,
-          current_step: message.current_step || (message.cookbook?.steps?.[0]?.id)
+          current_step: message.current_step || firstStepId
         };
         
         // Validate normalized message has required fields

package/src/index.js

@@ -11,17 +11,109 @@
  * @since 2.0.0
  */
 
+const path = require('path');
 const ServiceWrapper = require('./ServiceWrapper');
 const { ConfigLoader } = require('./ConfigLoader');
-const HttpLoggingMiddleware = require('./HttpLoggingMiddleware');
 
 // Note: WorkflowProcessor and ApiCaller functionality has been moved to connectors:
 // - WorkflowProcessor -> @onlineapps/conn-orch-orchestrator
 // - ApiCaller -> @onlineapps/conn-orch-api-mapper
 
+// Note: HTTP logging middleware is now in each service's middlewares/httpLogging.js
+// It uses lazy logger access via lib/logger.js (set after wrapper.initialize())
+
+/**
+ * Bootstrap a business service with standard configuration
+ * Eliminates boilerplate code in service index.js
+ * 
+ * @param {string} serviceRoot - Service root directory (__dirname from index.js)
+ * @param {Object} [options] - Optional overrides
+ * @param {Object} [options.app] - Express app (default: require('./src/app'))
+ * @param {Object} [options.config] - Config (default: require('./src/config'))
+ * @param {Function} [options.setLogger] - Logger setter (default: require('./src/lib/logger').setLogger)
+ * @returns {Promise<{wrapper: ServiceWrapper, server: Object}>}
+ * 
+ * @example
+ * // index.js (minimal)
+ * require('@onlineapps/service-wrapper').bootstrap(__dirname);
+ */
+async function bootstrap(serviceRoot, options = {}) {
+  // Load dotenv first
+  require('dotenv').config({ path: path.join(serviceRoot, '.env') });
+
+  // Load app, config, and logger from service
+  const app = options.app || require(path.join(serviceRoot, 'src', 'app'));
+  const config = options.config || require(path.join(serviceRoot, 'src', 'config'));
+  
+  // Logger setter is optional - some services may not have it
+  let setLogger = options.setLogger;
+  if (!setLogger) {
+    try {
+      const loggerModule = require(path.join(serviceRoot, 'src', 'lib', 'logger'));
+      setLogger = loggerModule.setLogger;
+    } catch (e) {
+      // No logger module - that's OK
+      setLogger = () => {};
+    }
+  }
+
+  console.log(`Starting ${config.service.name} v${config.service.version}...`);
+
+  // 1. Start HTTP server
+  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`);
+  });
+
+  // 2. Initialize Service Wrapper (MQ, Registry, Monitoring, etc.)
+  const wrapper = new ServiceWrapper({
+    app,
+    server,
+    serviceRoot,
+    config: {
+      service: {
+        name: config.service.name,
+        version: config.service.version,
+        port: config.service.port,
+        url: process.env.SERVICE_URL || `http://localhost:${PORT}`
+      },
+      wrapper: config.wrapper
+    },
+    operations: config.operations,
+    validationProof: config.validationProof
+  });
+
+  await wrapper.initialize();
+
+  // Initialize centralized logger for use throughout the service
+  if (setLogger && wrapper.logger) {
+    setLogger(wrapper.logger);
+  }
+
+  console.log(`✓ Service Wrapper initialized (MQ, Registry, Monitoring)`);
+  console.log(`✓ Local logs: logs/app.{date}.log`);
+  console.log(`✓ ${config.service.name} ready\n`);
+
+  // 3. Setup graceful shutdown
+  const shutdown = async () => {
+    console.log('\nShutting down gracefully...');
+    await wrapper.shutdown();
+    server.close(() => {
+      console.log('Server closed');
+      process.exit(0);
+    });
+  };
+
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT', shutdown);
+
+  return { wrapper, server };
+}
+
 module.exports = ServiceWrapper;
 module.exports.ServiceWrapper = ServiceWrapper;
 module.exports.ConfigLoader = ConfigLoader;
-module.exports.HttpLoggingMiddleware = HttpLoggingMiddleware;
+module.exports.bootstrap = bootstrap;
 module.exports.default = ServiceWrapper;
-module.exports.VERSION = '2.1.4';
+module.exports.VERSION = '2.1.10';

package/src/HttpLoggingMiddleware.js

@@ -1,295 +0,0 @@
-'use strict';
-
-/**
- * HTTP Logging Middleware
- * 
- * Configurable request/response logging for business services.
- * Logs to both local files and central monitoring via wrapper.logger.
- * 
- * Configuration in conn-config/config.json:
- * {
- *   "wrapper": {
- *     "logging": {
- *       "enabled": true,           // Master switch
- *       "level": "info",           // Log level: debug, info, warn, error
- *       "requests": {
- *         "enabled": true,         // Log incoming requests
- *         "bodies": true,          // Include request bodies
- *         "headers": false         // Include request headers (careful with auth tokens)
- *       },
- *       "responses": {
- *         "enabled": true,         // Log outgoing responses
- *         "bodies": true           // Include response bodies
- *       },
- *       "excludePaths": [          // Paths to exclude from logging
- *         "/health",
- *         "/status",
- *         "/metrics"
- *       ]
- *     }
- *   }
- * }
- */
-
-const DEFAULT_CONFIG = {
-  enabled: true,
-  level: 'info',
-  requests: {
-    enabled: true,
-    bodies: true,
-    headers: false
-  },
-  responses: {
-    enabled: true,
-    bodies: true
-  },
-  excludePaths: ['/health', '/status', '/metrics', '/specification']
-};
-
-/**
- * Merge user config with defaults
- */
-function mergeConfig(userConfig = {}) {
-  return {
-    enabled: userConfig.enabled ?? DEFAULT_CONFIG.enabled,
-    level: userConfig.level ?? DEFAULT_CONFIG.level,
-    requests: {
-      enabled: userConfig.requests?.enabled ?? DEFAULT_CONFIG.requests.enabled,
-      bodies: userConfig.requests?.bodies ?? DEFAULT_CONFIG.requests.bodies,
-      headers: userConfig.requests?.headers ?? DEFAULT_CONFIG.requests.headers
-    },
-    responses: {
-      enabled: userConfig.responses?.enabled ?? DEFAULT_CONFIG.responses.enabled,
-      bodies: userConfig.responses?.bodies ?? DEFAULT_CONFIG.responses.bodies
-    },
-    excludePaths: userConfig.excludePaths ?? DEFAULT_CONFIG.excludePaths
-  };
-}
-
-/**
- * Check if path should be excluded from logging
- */
-function shouldExclude(path, excludePaths) {
-  return excludePaths.some(excluded => {
-    // Exact match or prefix match
-    return path === excluded || path.startsWith(excluded + '/');
-  });
-}
-
-/**
- * Safely stringify body for logging
- */
-function safeStringify(body) {
-  if (body === undefined || body === null) {
-    return null;
-  }
-  
-  if (typeof body === 'string') {
-    // Already a string - could be JSON or plain text
-    try {
-      // Try to parse and re-stringify for consistent format
-      return JSON.parse(body);
-    } catch {
-      return body;
-    }
-  }
-  
-  if (Buffer.isBuffer(body)) {
-    return `[Buffer: ${body.length} bytes]`;
-  }
-  
-  // Object - return as is (will be serialized by logger)
-  return body;
-}
-
-/**
- * Create request logging middleware
- * @param {Function} getLogger - Function that returns logger instance
- * @param {Object} config - Logging configuration
- * @returns {Function} Express middleware
- */
-function createRequestLogger(getLogger, config) {
-  const cfg = mergeConfig(config);
-  
-  return (req, res, next) => {
-    // Skip if disabled
-    if (!cfg.enabled || !cfg.requests.enabled) {
-      return next();
-    }
-    
-    // Skip excluded paths
-    if (shouldExclude(req.path, cfg.excludePaths)) {
-      return next();
-    }
-    
-    const logger = getLogger();
-    if (!logger) {
-      return next();
-    }
-    
-    // Build log data
-    const logData = {
-      type: 'request',
-      method: req.method,
-      path: req.path,
-      url: req.originalUrl,
-      ip: req.ip || req.connection?.remoteAddress,
-      userAgent: req.get('user-agent')
-    };
-    
-    // Add query params if present
-    if (req.query && Object.keys(req.query).length > 0) {
-      logData.query = req.query;
-    }
-    
-    // Add request body if enabled
-    if (cfg.requests.bodies && req.body && Object.keys(req.body).length > 0) {
-      logData.body = safeStringify(req.body);
-    }
-    
-    // Add headers if enabled
-    if (cfg.requests.headers) {
-      // Filter out sensitive headers
-      const headers = { ...req.headers };
-      delete headers.authorization;
-      delete headers.cookie;
-      logData.headers = headers;
-    }
-    
-    // Store start time for response duration
-    req._loggingStartTime = Date.now();
-    
-    logger.info('HTTP Request', logData);
-    next();
-  };
-}
-
-/**
- * Create response logging middleware
- * @param {Function} getLogger - Function that returns logger instance
- * @param {Object} config - Logging configuration
- * @returns {Function} Express middleware
- */
-function createResponseLogger(getLogger, config) {
-  const cfg = mergeConfig(config);
-  
-  return (req, res, next) => {
-    // Skip if disabled
-    if (!cfg.enabled || !cfg.responses.enabled) {
-      return next();
-    }
-    
-    // Skip excluded paths
-    if (shouldExclude(req.path, cfg.excludePaths)) {
-      return next();
-    }
-    
-    const logger = getLogger();
-    if (!logger) {
-      return next();
-    }
-    
-    // Store original methods
-    const originalSend = res.send;
-    const originalJson = res.json;
-    
-    // Flag to prevent double logging
-    let logged = false;
-    
-    const logResponse = (body) => {
-      if (logged) return;
-      logged = true;
-      
-      const duration = req._loggingStartTime 
-        ? Date.now() - req._loggingStartTime 
-        : null;
-      
-      const logData = {
-        type: 'response',
-        method: req.method,
-        path: req.path,
-        statusCode: res.statusCode,
-        statusMessage: res.statusMessage
-      };
-      
-      if (duration !== null) {
-        logData.durationMs = duration;
-      }
-      
-      // Add response body if enabled
-      if (cfg.responses.bodies && body !== undefined) {
-        logData.body = safeStringify(body);
-      }
-      
-      // Choose log level based on status code
-      if (res.statusCode >= 500) {
-        logger.error('HTTP Response', logData);
-      } else if (res.statusCode >= 400) {
-        logger.warn('HTTP Response', logData);
-      } else {
-        logger.info('HTTP Response', logData);
-      }
-    };
-    
-    // Override res.send
-    res.send = function(body) {
-      logResponse(body);
-      return originalSend.call(this, body);
-    };
-    
-    // Override res.json
-    res.json = function(body) {
-      logResponse(body);
-      return originalJson.call(this, body);
-    };
-    
-    next();
-  };
-}
-
-/**
- * Create combined HTTP logging middleware
- * @param {Function} getLogger - Function that returns logger instance
- * @param {Object} config - Logging configuration from wrapper.logging
- * @returns {Object} Object with requestLogger and responseLogger middlewares
- */
-function createHttpLogging(getLogger, config = {}) {
-  const cfg = mergeConfig(config);
-  
-  return {
-    config: cfg,
-    requestLogger: createRequestLogger(getLogger, config),
-    responseLogger: createResponseLogger(getLogger, config),
-    
-    /**
-     * Apply both middlewares to Express app
-     * @param {Object} app - Express application
-     */
-    applyTo(app) {
-      if (!cfg.enabled) {
-        console.log('[HttpLogging] Disabled by configuration');
-        return;
-      }
-      
-      if (cfg.requests.enabled) {
-        app.use(this.requestLogger);
-      }
-      
-      if (cfg.responses.enabled) {
-        app.use(this.responseLogger);
-      }
-      
-      console.log(`[HttpLogging] Enabled (requests: ${cfg.requests.enabled}, responses: ${cfg.responses.enabled}, bodies: ${cfg.requests.bodies})`);
-      console.log(`[HttpLogging] Excluded paths: ${cfg.excludePaths.join(', ')}`);
-    }
-  };
-}
-
-module.exports = {
-  createHttpLogging,
-  createRequestLogger,
-  createResponseLogger,
-  mergeConfig,
-  DEFAULT_CONFIG
-};
-