@onlineapps/service-wrapper 2.0.0

package/src/ServiceWrapper.js

@@ -0,0 +1,343 @@
+'use strict';
+
+/**
+ * @module @onlineapps/service-wrapper
+ * @description Thin orchestration layer for microservices that handles all infrastructure concerns.
+ * Delegates all actual work to specialized connectors.
+ *
+ * @author OA Drive Team
+ * @license MIT
+ * @since 2.0.0
+ */
+
+// Import connectors
+const MQConnector = require('@onlineapps/conn-infra-mq');
+const RegistryConnector = require('@onlineapps/conn-orch-registry');
+const LoggerConnector = require('@onlineapps/conn-base-logger');
+const OrchestratorConnector = require('@onlineapps/conn-orch-orchestrator');
+const ApiMapperConnector = require('@onlineapps/conn-orch-api-mapper');
+const CookbookConnector = require('@onlineapps/conn-orch-cookbook');
+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();
+ */
+class ServiceWrapper {
+  /**
+   * Create a new ServiceWrapper instance
+   * @constructor
+   * @param {Object} options - Configuration options
+   * @param {Object} options.service - Express application instance
+   * @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
+   * @param {number} [options.config.prefetch=10] - MQ prefetch count
+   *
+   * @throws {Error} If required options are missing
+   */
+  constructor(options = {}) {
+    this._validateOptions(options);
+
+    // Store configuration
+    this.service = options.service;
+    this.serviceName = options.serviceName;
+    this.openApiSpec = options.openApiSpec;
+    this.config = options.config || {};
+
+    // Initialize connectors
+    this.logger = LoggerConnector.create(this.serviceName);
+    this.mqClient = null;
+    this.registryClient = null;
+    this.orchestrator = null;
+    this.cacheConnector = null;
+
+    // State
+    this.isRunning = false;
+  }
+
+  /**
+   * Validate constructor options
+   * @private
+   * @param {Object} options - Options to validate
+   * @throws {Error} If required options are missing
+   */
+  _validateOptions(options) {
+    if (!options.service) {
+      throw new Error('Service (Express app) is required');
+    }
+    if (!options.serviceName) {
+      throw new Error('Service name is required');
+    }
+    if (!options.openApiSpec) {
+      throw new Error('OpenAPI specification is required');
+    }
+  }
+
+  /**
+   * Start the service wrapper
+   * @async
+   * @method start
+   * @returns {Promise<void>}
+   *
+   * @example
+   * await wrapper.start();
+   * console.log('Service wrapper started');
+   */
+  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');
+      }
+
+      // 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
+      this.orchestrator = OrchestratorConnector.create({
+        mqClient: this.mqClient,
+        registryClient: this.registryClient,
+        apiMapper: ApiMapperConnector.create({
+          openApiSpec: this.openApiSpec,
+          serviceUrl: `http://localhost:${this.config.port || 3000}`,
+          service: this.service,
+          directCall: true,
+          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}`);
+
+    } catch (error) {
+      this.logger.error('Failed to start service wrapper', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the service wrapper
+   * @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');
+      return;
+    }
+
+    try {
+      this.logger.info(`Stopping service wrapper for ${this.serviceName}`);
+
+      // Stop heartbeat
+      if (this.heartbeatInterval) {
+        clearInterval(this.heartbeatInterval);
+      }
+
+      // Unregister from registry
+      if (this.registryClient) {
+        await this.registryClient.unregister(this.serviceName);
+      }
+
+      // Disconnect from cache
+      if (this.cacheConnector) {
+        await this.cacheConnector.disconnect();
+      }
+
+      // Disconnect from MQ
+      if (this.mqClient) {
+        await this.mqClient.disconnect();
+      }
+
+      this.isRunning = false;
+      this.logger.info(`Service wrapper stopped successfully for ${this.serviceName}`);
+
+    } catch (error) {
+      this.logger.error('Error stopping service wrapper', { error: error.message });
+      throw error;
+    }
+  }
+
+  /**
+   * Initialize infrastructure connectors
+   * @private
+   * @async
+   * @returns {Promise<void>}
+   */
+  async _initializeConnectors() {
+    // Initialize MQ client
+    this.mqClient = new MQConnector({
+      url: this.config.rabbitmq || process.env.RABBITMQ_URL || 'amqp://localhost:5672',
+      serviceName: this.serviceName,
+      prefetchCount: this.config.prefetch || 10,
+      logger: this.logger
+    });
+    await this.mqClient.connect();
+
+    // Initialize registry client
+    this.registryClient = new RegistryConnector.ServiceRegistryClient({
+      registryUrl: this.config.registry || process.env.REGISTRY_URL || 'http://localhost:4000',
+      logger: this.logger
+    });
+  }
+
+  /**
+   * Register service with registry
+   * @private
+   * @async
+   * @returns {Promise<void>}
+   */
+  async _registerService() {
+    const serviceInfo = {
+      name: this.serviceName,
+      url: `http://localhost:${this.config.port || 3000}`,
+      openapi: this.openApiSpec,
+      metadata: {
+        version: this.openApiSpec.info?.version || '1.0.0',
+        description: this.openApiSpec.info?.description || ''
+      }
+    };
+
+    await this.registryClient.register(serviceInfo);
+    this.logger.info(`Service registered: ${this.serviceName}`);
+  }
+
+  /**
+   * Subscribe to workflow message queues
+   * @private
+   * @async
+   * @returns {Promise<void>}
+   */
+  async _subscribeToQueues() {
+    const queueName = `${this.serviceName}.workflow`;
+
+    // Subscribe to workflow messages
+    await this.mqClient.consume(
+      async (message) => {
+        try {
+          // Delegate ALL processing to orchestrator
+          const result = await this.orchestrator.processWorkflowMessage(
+            message,
+            this.serviceName
+          );
+
+          this.logger.info('Message processed successfully', {
+            workflow_id: message.workflow_id,
+            step: message.current_step,
+            result
+          });
+
+        } catch (error) {
+          this.logger.error('Message processing failed', {
+            workflow_id: message.workflow_id,
+            step: message.current_step,
+            error: error.message
+          });
+        }
+      },
+      { queue: queueName }
+    );
+
+    this.logger.info(`Subscribed to queue: ${queueName}`);
+  }
+
+  /**
+   * Start service heartbeat
+   * @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 });
+      }
+    }, this.config.heartbeatInterval || 30000);
+  }
+
+  /**
+   * 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
+      }
+    };
+  }
+}
+
+module.exports = ServiceWrapper;

package/src/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/**
+ * @module @onlineapps/service-wrapper
+ * @description Infrastructure orchestration for microservices.
+ * Thin layer that delegates all work to specialized connectors.
+ *
+ * @see {@link https://github.com/onlineapps/oa-drive/tree/main/shared/service-wrapper|GitHub Repository}
+ * @author OA Drive Team
+ * @license MIT
+ * @since 2.0.0
+ */
+
+const ServiceWrapper = require('./ServiceWrapper');
+
+// Note: WorkflowProcessor and ApiCaller functionality has been moved to connectors:
+// - WorkflowProcessor -> @onlineapps/conn-orch-orchestrator
+// - ApiCaller -> @onlineapps/conn-orch-api-mapper
+
+module.exports = ServiceWrapper;
+module.exports.ServiceWrapper = ServiceWrapper;
+module.exports.default = ServiceWrapper;
+module.exports.VERSION = '2.0.0';