@onlineapps/service-wrapper 2.0.7 → 2.0.9

package/src/ServiceWrapper.js

@@ -1,19 +1,21 @@
 'use strict';
 
 /**
- * @module @onlineapps/service-wrapper
- * @description Thin orchestration layer for microservices that handles all infrastructure concerns.
- * Delegates all actual work to specialized connectors.
+ * Service Wrapper - Collection of connectors for business services
  *
- * @author OA Drive Team
- * @license MIT
- * @since 2.0.0
+ * Provides infrastructure components in single-process architecture:
+ * - MQ integration (RabbitMQ)
+ * - Service discovery (Registry)
+ * - Monitoring and metrics
+ * - Health checks
+ *
+ * Uses HTTP pattern exclusively - no direct handler calls
  */
 
 // Import connectors
 const MQConnector = require('@onlineapps/conn-infra-mq');
 const RegistryConnector = require('@onlineapps/conn-orch-registry');
-const LoggerConnector = require('@onlineapps/conn-base-logger');
+const MonitoringConnector = require('@onlineapps/conn-base-monitoring');
 const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
 const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
 const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
@@ -21,373 +23,534 @@ const CacheConnector = require('@onlineapps/conn-base-cache');
 const ErrorHandlerConnector = require('@onlineapps/conn-infra-error-handler');
 
 /**
- * @class ServiceWrapper
- * @description Thin wrapper that orchestrates all infrastructure concerns for a microservice.
- * ALL actual functionality is delegated to specialized connectors.
- *
- * @example
- * const wrapper = new ServiceWrapper({
- *   service: expressApp,
- *   serviceName: 'hello-service',
- *   openApiSpec: require('./openapi.json'),
- *   config: {
- *     rabbitmq: process.env.RABBITMQ_URL,
- *     redis: process.env.REDIS_HOST,
- *     registry: process.env.REGISTRY_URL
- *   }
- * });
- *
- * await wrapper.start();
+ * ServiceWrapper class
+ * Collection of connectors that enhance business service with infrastructure
  */
 class ServiceWrapper {
   /**
    * Create a new ServiceWrapper instance
-   * @constructor
    * @param {Object} options - Configuration options
-   * @param {Object} [options.service] - Express application instance (for direct calls)
-   * @param {string} [options.serviceUrl] - HTTP URL of the service (for HTTP calls)
-   * @param {string} options.serviceName - Name of the service
-   * @param {Object} options.openApiSpec - OpenAPI specification
-   * @param {Object} [options.config={}] - Infrastructure configuration
-   * @param {string} [options.config.rabbitmq] - RabbitMQ connection URL
-   * @param {string} [options.config.redis] - Redis connection string
-   * @param {string} [options.config.registry] - Registry service URL
-   * @param {number} [options.config.port=3000] - Service port (deprecated, use serviceUrl)
-   * @param {number} [options.config.prefetch=10] - MQ prefetch count
-   * @param {boolean} [options.config.directCall] - Use direct Express calls (default: auto-detect)
-   *
-   * @throws {Error} If required options are missing
+   * @param {Object} options.app - Express application instance
+   * @param {Object} options.server - HTTP server instance
+   * @param {Object} options.config - Service and wrapper configuration
+   * @param {Object} options.operations - Operations schema
    */
   constructor(options = {}) {
     this._validateOptions(options);
 
     // Store configuration
-    this.service = options.service;
-    this.serviceUrl = options.serviceUrl;
-    this.serviceName = options.serviceName;
-    this.openApiSpec = options.openApiSpec;
-    this.config = options.config || {};
-
-    // Initialize connectors
-    this.logger = new LoggerConnector({ serviceName: this.serviceName });
+    this.app = options.app;
+    this.server = options.server;
+    this.config = this._processConfig(options.config);
+    this.operations = options.operations;
+
+    // Initialize connector placeholders
     this.mqClient = null;
     this.registryClient = null;
     this.orchestrator = null;
     this.cacheConnector = null;
+    this.monitoring = null;
+    this.logger = null;
 
     // State
-    this.isRunning = false;
+    this.isInitialized = false;
   }
 
   /**
    * Validate constructor options
    * @private
-   * @param {Object} options - Options to validate
-   * @throws {Error} If required options are missing
    */
   _validateOptions(options) {
-    if (!options.service && !options.serviceUrl) {
-      throw new Error('Either service (Express app) or serviceUrl is required');
+    if (!options.app) {
+      throw new Error('Express app instance is required');
+    }
+    if (!options.server) {
+      throw new Error('HTTP server instance is required');
     }
-    if (!options.serviceName) {
-      throw new Error('Service name is required');
+    if (!options.config) {
+      throw new Error('Configuration is required');
     }
-    if (!options.openApiSpec) {
-      throw new Error('OpenAPI specification is required');
+    if (!options.operations) {
+      throw new Error('Operations schema is required');
     }
   }
 
   /**
-   * Start the service wrapper
-   * @async
-   * @method start
-   * @returns {Promise<void>}
-   *
-   * @example
-   * await wrapper.start();
-   * console.log('Service wrapper started');
+   * Process and validate configuration
+   * @private
    */
-  async start() {
-    if (this.isRunning) {
-      this.logger.warn('Service wrapper already running');
-      return;
-    }
-
-    try {
-      this.logger.info(`Starting service wrapper for ${this.serviceName}`);
-
-      // 1. Initialize infrastructure connectors
-      await this._initializeConnectors();
-
-      // 2. Initialize cache connector if Redis is configured
-      if (this.config.redis) {
-        this.cacheConnector = new CacheConnector({
-          host: this.config.redis,
-          namespace: this.serviceName,
-          defaultTTL: this.config.cacheTTL || 300
-        });
-        await this.cacheConnector.connect();
-        this.logger.info('Cache connector initialized');
+  _processConfig(config) {
+    // Replace environment variables in config
+    const processValue = (value) => {
+      if (typeof value === 'string' && value.startsWith('${') && value.endsWith('}')) {
+        const envVar = value.slice(2, -1);
+        const [varName, defaultValue] = envVar.split(':');
+        return process.env[varName] || defaultValue || '';
       }
+      return value;
+    };
 
-      // 3. Initialize error handler
-      const errorHandler = new ErrorHandlerConnector({
-        maxRetries: this.config.maxRetries || 3,
-        retryDelay: this.config.retryDelay || 1000,
-        logger: this.logger
-      });
-
-      // 4. Create the orchestrator with all dependencies
-      // Determine if we should use direct calls or HTTP
-      const useDirectCall = this.config.directCall !== undefined
-        ? this.config.directCall
-        : (this.service && !this.serviceUrl); // Auto-detect based on what was provided
-
-      const serviceUrl = this.serviceUrl || `http://localhost:${this.config.port || 3000}`;
-
-      this.orchestrator = OrchestratorConnector.create({
-        mqClient: this.mqClient,
-        registryClient: this.registryClient,
-        apiMapper: ApiMapperConnector.create({
-          openApiSpec: this.openApiSpec,
-          serviceUrl: serviceUrl,
-          service: this.service,
-          directCall: useDirectCall,
-          logger: this.logger
-        }),
-        cookbook: CookbookConnector,
-        cache: this.cacheConnector,
-        errorHandler: errorHandler,
-        logger: this.logger,
-        defaultTimeout: this.config.defaultTimeout || 30000
-      });
-
-      // 5. Register service with registry
-      await this._registerService();
-
-      // 6. Subscribe to workflow messages
-      await this._subscribeToQueues();
-
-      // 7. Start heartbeat
-      this._startHeartbeat();
-
-      this.isRunning = true;
-      this.logger.info(`Service wrapper started successfully for ${this.serviceName}`);
+    // Recursively process config object
+    const processObject = (obj) => {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+          result[key] = processObject(value);
+        } else {
+          result[key] = processValue(value);
+        }
+      }
+      return result;
+    };
 
-    } catch (error) {
-      this.logger.error('Failed to start service wrapper', { error: error.message });
-      throw error;
-    }
+    return processObject(config);
   }
 
   /**
-   * Stop the service wrapper
+   * Initialize all wrapper components
    * @async
-   * @method stop
-   * @returns {Promise<void>}
-   *
-   * @example
-   * await wrapper.stop();
-   * console.log('Service wrapper stopped');
    */
-  async stop() {
-    if (!this.isRunning) {
-      this.logger.warn('Service wrapper not running');
+  async initialize() {
+    if (this.isInitialized) {
+      console.warn('ServiceWrapper already initialized');
       return;
     }
 
     try {
-      this.logger.info(`Stopping service wrapper for ${this.serviceName}`);
+      const serviceName = this.config.service?.name || 'unnamed-service';
+      console.log(`Initializing ServiceWrapper for ${serviceName}`);
 
-      // Stop heartbeat
-      if (this.heartbeatInterval) {
-        clearInterval(this.heartbeatInterval);
+      // 1. Initialize monitoring first (needed for logging)
+      if (this.config.wrapper?.monitoring?.enabled !== false) {
+        await this._initializeMonitoring();
       }
 
-      // Unregister from registry
-      if (this.registryClient) {
-        await this.registryClient.unregister(this.serviceName);
+      // 2. Initialize MQ connection
+      if (this.config.wrapper?.mq?.enabled !== false) {
+        await this._initializeMQ();
       }
 
-      // Disconnect from cache
-      if (this.cacheConnector) {
-        await this.cacheConnector.disconnect();
+      // 3. Initialize service registry
+      if (this.config.wrapper?.registry?.enabled !== false) {
+        await this._initializeRegistry();
       }
 
-      // Disconnect from MQ
+      // 4. Initialize cache if configured
+      if (this.config.wrapper?.cache?.enabled === true) {
+        await this._initializeCache();
+      }
+
+      // 5. Setup health checks
+      if (this.config.wrapper?.health?.enabled !== false) {
+        this._setupHealthChecks();
+      }
+
+      // 6. Initialize orchestrator for workflow processing
       if (this.mqClient) {
-        await this.mqClient.disconnect();
+        await this._initializeOrchestrator();
+        await this._subscribeToQueues();
       }
 
-      this.isRunning = false;
-      this.logger.info(`Service wrapper stopped successfully for ${this.serviceName}`);
+      this.isInitialized = true;
+      console.log(`ServiceWrapper initialized successfully for ${serviceName}`);
 
     } catch (error) {
-      this.logger.error('Error stopping service wrapper', { error: error.message });
+      console.error('Failed to initialize ServiceWrapper:', error);
       throw error;
     }
   }
 
   /**
-   * Initialize infrastructure connectors
+   * Initialize monitoring
+   * @private
+   */
+  async _initializeMonitoring() {
+    const serviceName = this.config.service?.name || 'unnamed-service';
+
+    this.monitoring = MonitoringConnector;
+    await this.monitoring.init({
+      serviceName,
+      ...this.config.wrapper?.monitoring
+    });
+
+    this.logger = this.monitoring;
+    console.log('Monitoring connector initialized');
+
+    // Add monitoring middleware to Express app
+    if (this.app) {
+      this.app.use((req, res, next) => {
+        const start = Date.now();
+
+        res.on('finish', () => {
+          const duration = Date.now() - start;
+          this.monitoring.info('Request processed', {
+            method: req.method,
+            path: req.path,
+            statusCode: res.statusCode,
+            duration
+          });
+        });
+
+        next();
+      });
+    }
+  }
+
+  /**
+   * Initialize MQ connection
    * @private
-   * @async
-   * @returns {Promise<void>}
    */
-  async _initializeConnectors() {
-    // Initialize MQ client with correct config format
-    const rabbitUrl = this.config.rabbitmq || process.env.RABBITMQ_URL || 'amqp://localhost:5672';
+  async _initializeMQ() {
+    const mqUrl = this.config.wrapper?.mq?.url;
+    if (!mqUrl) {
+      throw new Error('MQ URL is required when MQ is enabled. Set wrapper.mq.url in config');
+    }
+
+    const serviceName = this.config.service?.name || 'unnamed-service';
 
     this.mqClient = new MQConnector({
       type: 'rabbitmq',
-      host: rabbitUrl,
-      queue: `${this.serviceName}.workflow`,
-      prefetch: this.config.prefetch || 10,
+      host: mqUrl,
+      queue: `${serviceName}.workflow`,
+      prefetch: this.config.wrapper?.mq?.prefetch || 10,
       durable: true,
       noAck: false,
-      logger: {
-        info: (...args) => this.logger.info(...args),
-        warn: (...args) => this.logger.warn(...args),
-        error: (...args) => this.logger.error(...args),
-        debug: (...args) => this.logger.debug(...args)
-      }
+      logger: this.logger || console
     });
-    await this.mqClient.connect();
 
-    // Initialize registry client with required parameters
-    this.registryClient = new RegistryConnector.ServiceRegistryClient({
-      amqpUrl: rabbitUrl,
-      serviceName: this.serviceName,
-      version: this.openApiSpec?.info?.version || '1.0.0',
-      registryUrl: this.config.registry || process.env.REGISTRY_URL || 'http://localhost:4000',
-      logger: this.logger
-    });
+    await this.mqClient.connect();
+    console.log('MQ connector initialized');
   }
 
   /**
-   * Register service with registry
+   * Initialize service registry
    * @private
-   * @async
-   * @returns {Promise<void>}
    */
-  async _registerService() {
-    const serviceUrl = this.serviceUrl || `http://localhost:${this.config.port || 3000}`;
+  async _initializeRegistry() {
+    const registryUrl = this.config.wrapper?.registry?.url;
+    if (!registryUrl) {
+      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 || '';
+
+    this.registryClient = new RegistryConnector.ServiceRegistryClient({
+      amqpUrl: mqUrl,
+      serviceName: serviceName,
+      version: this.config.service?.version || '1.0.0',
+      registryUrl: registryUrl,
+      logger: this.logger || console
+    });
+
+    // Register service
     const serviceInfo = {
-      name: this.serviceName,
-      url: serviceUrl,
-      openapi: this.openApiSpec,
+      name: serviceName,
+      url: `http://localhost:${servicePort}`,
+      operations: this.operations?.operations || {},
       metadata: {
-        version: this.openApiSpec.info?.version || '1.0.0',
-        description: this.openApiSpec.info?.description || ''
+        version: this.config.service?.version || '1.0.0',
+        description: this.config.service?.description || ''
       }
     };
 
     await this.registryClient.register(serviceInfo);
-    this.logger.info(`Service registered: ${this.serviceName}`);
+    console.log(`Service registered: ${serviceName}`);
+
+    // Start heartbeat
+    const heartbeatInterval = this.config.wrapper?.registry?.heartbeatInterval || 30000;
+    this.heartbeatTimer = setInterval(async () => {
+      try {
+        await this.registryClient.sendHeartbeat(serviceName);
+      } catch (error) {
+        console.error('Heartbeat failed:', error.message);
+      }
+    }, heartbeatInterval);
   }
 
   /**
-   * Subscribe to workflow message queues
+   * Initialize cache connector
    * @private
-   * @async
-   * @returns {Promise<void>}
    */
-  async _subscribeToQueues() {
-    const queueName = `${this.serviceName}.workflow`;
-
-    // Subscribe to workflow messages
-    await this.mqClient.consume(
-      queueName,
-      async (rawMessage) => {
-        try {
-          // Parse message content if it's a buffer (AMQP message)
-          let message;
-          if (rawMessage && rawMessage.content) {
-            // This is an AMQP message with content buffer
-            const messageContent = rawMessage.content.toString();
-            try {
-              message = JSON.parse(messageContent);
-            } catch (parseError) {
-              this.logger.error('Failed to parse message content', {
-                error: parseError.message,
-                content: messageContent
-              });
-              throw parseError;
-            }
-          } else {
-            // Already parsed or direct message
-            message = rawMessage;
-          }
+  async _initializeCache() {
+    const cacheUrl = this.config.wrapper?.cache?.url;
+    if (!cacheUrl) {
+      console.warn('Cache enabled but no URL provided. Skipping cache initialization');
+      return;
+    }
 
-          // DEBUG: Log the actual message structure
-          this.logger.info('DEBUG: Received message structure', {
-            workflow_id: message.workflow_id,
-            has_cookbook: !!message.cookbook,
-            cookbook_name: message.cookbook?.name,
-            cookbook_steps: message.cookbook?.steps?.length,
-            first_step: message.cookbook?.steps?.[0],
-            current_step: message.current_step
-          });
+    const serviceName = this.config.service?.name || 'unnamed-service';
 
-          // Delegate ALL processing to orchestrator
-          const result = await this.orchestrator.processWorkflowMessage(
-            message,
-            this.serviceName
-          );
+    this.cacheConnector = new CacheConnector({
+      host: cacheUrl,
+      namespace: serviceName,
+      defaultTTL: this.config.wrapper?.cache?.ttl || 300
+    });
 
-          this.logger.info('Message processed successfully', {
-            workflow_id: message.workflow_id,
-            step: message.current_step,
-            result
-          });
+    await this.cacheConnector.connect();
+    console.log('Cache connector initialized');
+  }
 
-        } catch (error) {
-          this.logger.error('Message processing failed', {
-            workflow_id: message?.workflow_id || 'unknown',
-            step: message?.current_step || 'unknown',
-            error: error.message
-          });
+  /**
+   * Setup health check endpoint
+   * @private
+   */
+  _setupHealthChecks() {
+    const healthEndpoint = this.config.wrapper?.health?.endpoint || '/health';
+
+    this.app.get(healthEndpoint, (req, res) => {
+      const health = {
+        status: 'healthy',
+        service: this.config.service?.name || 'unnamed-service',
+        timestamp: new Date().toISOString(),
+        components: {
+          http: 'healthy',
+          mq: this.mqClient?.isConnected() ? 'healthy' : 'unhealthy',
+          registry: this.registryClient ? 'healthy' : 'disabled',
+          cache: this.cacheConnector ? 'healthy' : 'disabled'
         }
+      };
+
+      // Determine overall status
+      const statuses = Object.values(health.components);
+      if (statuses.includes('unhealthy')) {
+        health.status = 'unhealthy';
+        res.status(503);
+      } else {
+        res.status(200);
       }
-    );
 
-    this.logger.info(`Subscribed to queue: ${queueName}`);
+      res.json(health);
+    });
+
+    console.log(`Health check endpoint registered at ${healthEndpoint}`);
   }
 
   /**
-   * Start service heartbeat
+   * Initialize orchestrator for workflow processing
    * @private
    */
-  _startHeartbeat() {
-    this.heartbeatInterval = setInterval(async () => {
-      try {
-        await this.registryClient.sendHeartbeat(this.serviceName);
-        this.logger.debug(`Heartbeat sent for ${this.serviceName}`);
-      } catch (error) {
-        this.logger.error('Heartbeat failed', { error: error.message });
+  async _initializeOrchestrator() {
+    const servicePort = this.config.service?.port || process.env.PORT || 3000;
+    const serviceUrl = `http://localhost:${servicePort}`;
+
+    // Create error handler
+    const errorHandler = new ErrorHandlerConnector({
+      maxRetries: this.config.wrapper?.errorHandling?.maxRetries || 3,
+      retryDelay: this.config.wrapper?.errorHandling?.retryDelay || 1000,
+      logger: this.logger || console
+    });
+
+    // Create API mapper for HTTP calls (never direct calls)
+    const apiMapper = ApiMapperConnector.create({
+      openApiSpec: this.operations, // Using operations.json instead of OpenAPI
+      serviceUrl: serviceUrl,
+      directCall: false, // ALWAYS use HTTP pattern
+      logger: this.logger || console
+    });
+
+    // Create orchestrator
+    this.orchestrator = OrchestratorConnector.create({
+      mqClient: this.mqClient,
+      registryClient: this.registryClient,
+      apiMapper: apiMapper,
+      cookbook: CookbookConnector,
+      cache: this.cacheConnector,
+      errorHandler: errorHandler,
+      logger: this.logger || console,
+      defaultTimeout: this.config.wrapper?.timeout || 30000
+    });
+
+    console.log('Orchestrator initialized');
+  }
+
+  /**
+   * Subscribe to workflow queues
+   * @private
+   */
+  async _subscribeToQueues() {
+    const serviceName = this.config.service?.name || 'unnamed-service';
+
+    // Subscribe to workflow.init queue (for all services)
+    await this.mqClient.consume('workflow.init', async (message) => {
+      await this._processWorkflowMessage(message, 'workflow.init');
+    });
+
+    // Subscribe to service-specific queue
+    const serviceQueue = `${serviceName}.workflow`;
+    await this.mqClient.consume(serviceQueue, async (message) => {
+      await this._processWorkflowMessage(message, serviceQueue);
+    });
+
+    console.log(`Subscribed to queues: workflow.init, ${serviceQueue}`);
+  }
+
+  /**
+   * Process workflow message
+   * @private
+   */
+  async _processWorkflowMessage(rawMessage, queueName) {
+    try {
+      // Parse message
+      let message;
+      if (rawMessage && rawMessage.content) {
+        // AMQP message with content buffer
+        const messageContent = rawMessage.content.toString();
+        message = JSON.parse(messageContent);
+      } else {
+        // Already parsed message
+        message = rawMessage;
       }
-    }, this.config.heartbeatInterval || 30000);
+
+      console.log(`Processing message from ${queueName}:`, {
+        workflow_id: message.workflow_id,
+        step: message.step?.operation || message.operation
+      });
+
+      // Check if this message is for our service
+      const serviceName = this.config.service?.name || 'unnamed-service';
+      if (message.step?.service && message.step.service !== serviceName) {
+        console.log(`Message not for this service (target: ${message.step.service})`);
+        return;
+      }
+
+      // Process based on message type
+      if (message.operation && this.operations?.operations?.[message.operation]) {
+        // Direct operation call
+        const result = await this._executeOperation(message.operation, message.input || {});
+        return result;
+      } else if (message.step?.operation && this.operations?.operations?.[message.step.operation]) {
+        // Workflow step
+        const result = await this._executeOperation(message.step.operation, message.input || {});
+        return result;
+      } else if (this.orchestrator) {
+        // Delegate to orchestrator for complex workflow processing
+        const result = await this.orchestrator.processWorkflowMessage(message, serviceName);
+        return result;
+      } else {
+        throw new Error(`Unknown message format or operation: ${JSON.stringify(message)}`);
+      }
+
+    } catch (error) {
+      console.error(`Error processing message from ${queueName}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Execute operation by calling HTTP endpoint
+   * @private
+   */
+  async _executeOperation(operationName, input) {
+    const operation = this.operations?.operations?.[operationName];
+    if (!operation) {
+      throw new Error(`Unknown operation: ${operationName}`);
+    }
+
+    const servicePort = this.config.service?.port || process.env.PORT || 3000;
+    const url = `http://localhost:${servicePort}${operation.endpoint}`;
+    const method = operation.method || 'POST';
+
+    console.log(`Executing operation ${operationName} via ${method} ${url}`);
+
+    // Make HTTP request using fetch (Node.js 18+) or http module
+    const http = require('http');
+
+    return new Promise((resolve, reject) => {
+      const postData = JSON.stringify(input);
+
+      const options = {
+        hostname: 'localhost',
+        port: servicePort,
+        path: operation.endpoint,
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      };
+
+      const req = http.request(options, (res) => {
+        let data = '';
+
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              resolve(result);
+            } else {
+              reject(new Error(`Operation failed: ${result.error || data}`));
+            }
+          } catch (error) {
+            reject(new Error(`Invalid response: ${data}`));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  /**
+   * Shutdown wrapper and cleanup resources
+   * @async
+   */
+  async shutdown() {
+    const serviceName = this.config.service?.name || 'unnamed-service';
+    console.log(`Shutting down ServiceWrapper for ${serviceName}`);
+
+    try {
+      // Stop heartbeat
+      if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+      }
+
+      // Unregister from registry
+      if (this.registryClient) {
+        await this.registryClient.unregister(serviceName);
+      }
+
+      // Disconnect from cache
+      if (this.cacheConnector) {
+        await this.cacheConnector.disconnect();
+      }
+
+      // Disconnect from MQ
+      if (this.mqClient) {
+        await this.mqClient.disconnect();
+      }
+
+      this.isInitialized = false;
+      console.log('ServiceWrapper shutdown complete');
+
+    } catch (error) {
+      console.error('Error during shutdown:', error);
+      throw error;
+    }
   }
 
   /**
    * Get wrapper status
-   * @method getStatus
-   * @returns {Object} Status information
-   *
-   * @example
-   * const status = wrapper.getStatus();
-   * console.log('Wrapper status:', status);
    */
   getStatus() {
     return {
-      serviceName: this.serviceName,
-      isRunning: this.isRunning,
-      mqConnected: this.mqClient?.isConnected() || false,
-      registryConnected: this.registryClient?.isConnected() || false,
-      config: {
-        port: this.config.port || 3000,
-        prefetch: this.config.prefetch || 10,
-        heartbeatInterval: this.config.heartbeatInterval || 30000
+      initialized: this.isInitialized,
+      service: this.config.service?.name || 'unnamed-service',
+      components: {
+        mq: this.mqClient?.isConnected() || false,
+        registry: !!this.registryClient,
+        cache: !!this.cacheConnector,
+        monitoring: !!this.monitoring
       }
     };
   }