@onlineapps/conn-base-hub 1.0.0

package/jest.integration.config.js

@@ -0,0 +1,9 @@
+// Separate Jest config for integration tests
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['**/test/integration/**/*.test.js'],
+  testTimeout: 30000, // Longer timeout for integration tests
+  globalSetup: './test/integration/setup.js',
+  coverageDirectory: 'coverage-integration',
+  verbose: true
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@onlineapps/conn-base-hub",
+  "version": "1.0.0",
+  "description": "Central hub for OA Drive connectors - bundles and integrates all essential connector libraries",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest",
+    "test:unit": "jest --testPathPattern=unit --coverage",
+    "test:component": "jest --testPathPattern=component --coverage",
+    "test:integration": "jest --config=jest.integration.config.js",
+    "test:integration:required": "REQUIRE_SERVICES=true jest --config=jest.integration.config.js",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage --coverageReporters=text-lcov html"
+  },
+  "keywords": [
+    "connector",
+    "microservice",
+    "integration",
+    "workflow",
+    "mq",
+    "registry"
+  ],
+  "dependencies": {
+    "@onlineapps/conn-orch-cookbook": "^2.0.0",
+    "@onlineapps/conn-base-logger": "^1.0.0",
+    "@onlineapps/conn-infra-mq": "^1.1.0",
+    "@onlineapps/conn-orch-registry": "^1.1.4",
+    "@onlineapps/conn-base-storage": "^1.0.0",
+    "dotenv": "^16.0.3"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "author": "OA Drive Team",
+  "license": "ISC"
+}

package/src/index.js

@@ -0,0 +1,274 @@
+/**
+ * @onlineapps/connector-core
+ *
+ * Core integration library that bundles all essential connectors
+ * for OA Drive microservices. Provides a unified interface for:
+ * - Message Queue operations
+ * - Service Registry registration and discovery
+ * - Workflow cookbook processing
+ * - Storage operations with MinIO
+ * - Centralized logging
+ */
+
+require('dotenv').config();
+
+// Re-export all connectors
+module.exports = {
+  // MQ Client for RabbitMQ communication
+  MQClient: require('@onlineapps/conn-infra-mq'),
+
+  // Service Registry client for registration and event consumption
+  ...require('@onlineapps/conn-orch-registry'),
+
+  // Cookbook validation and processing
+  ...require('@onlineapps/conn-orch-cookbook'),
+
+  // Storage connector for MinIO with fingerprinting
+  StorageConnector: require('@onlineapps/conn-base-storage'),
+
+  // Logger (if available)
+  createLogger: (() => {
+    try {
+      return require('@onlineapps/conn-base-logger');
+    } catch (e) {
+      // Logger not available, return console as fallback
+      return function(config) {
+        return {
+          info: console.log,
+          error: console.error,
+          warn: console.warn,
+          debug: console.debug,
+          api: { info: console.log, error: console.error },
+          mq: { info: console.log, error: console.error },
+          workflow: { info: console.log, error: console.error },
+          registry: { info: console.log, error: console.error },
+          close: async () => {}
+        };
+      };
+    }
+  })(),
+
+  // Convenience factory for creating a fully configured microservice
+  createMicroservice: function(config) {
+    const { ServiceRegistryClient, MQClient, StorageConnector, createLogger } = module.exports;
+
+    // Create logger instance
+    const logger = createLogger({
+      serviceName: config.serviceName,
+      version: config.version,
+      ...config.logger
+    });
+
+    return {
+      logger,
+      // Initialize Registry Client
+      registry: config.registry ? new ServiceRegistryClient({
+        amqpUrl: config.amqpUrl || process.env.RABBITMQ_URL,
+        serviceName: config.serviceName,
+        version: config.version || '1.0.0',
+        ...config.registry
+      }) : null,
+
+      // Initialize MQ Client
+      mq: config.mq ? new MQClient({
+        type: 'rabbitmq',
+        host: config.amqpUrl || process.env.RABBITMQ_URL,
+        queue: `${config.serviceName}_queue`,
+        ...config.mq
+      }) : null,
+
+      // Initialize Storage
+      storage: config.storage ? new StorageConnector({
+        endPoint: process.env.MINIO_ENDPOINT || 'localhost',
+        port: parseInt(process.env.MINIO_PORT || 9000),
+        accessKey: process.env.MINIO_ACCESS_KEY || 'minioadmin',
+        secretKey: process.env.MINIO_SECRET_KEY || 'minioadmin',
+        ...config.storage
+      }) : null,
+
+      // Initialize all components
+      async init() {
+        const results = {};
+
+        // Initialize Registry
+        if (this.registry) {
+          await this.registry.initialize();
+
+          // Optionally subscribe to changes
+          if (config.subscribeToRegistry) {
+            await this.registry.subscribeToChanges();
+          }
+
+          // Start heartbeat
+          this.registry.startHeartbeat();
+          results.registry = true;
+        }
+
+        // Initialize MQ
+        if (this.mq) {
+          await this.mq.connect();
+          results.mq = true;
+        }
+
+        // Initialize Storage
+        if (this.storage) {
+          await this.storage.initialize();
+          results.storage = true;
+        }
+
+        return results;
+      },
+
+      // Graceful shutdown
+      async shutdown() {
+        const promises = [];
+
+        if (this.registry) {
+          promises.push(this.registry.dispose());
+        }
+
+        if (this.mq) {
+          promises.push(this.mq.disconnect());
+        }
+
+        if (this.logger && this.logger.close) {
+          promises.push(this.logger.close());
+        }
+
+        await Promise.all(promises);
+      }
+    };
+  },
+
+  // Helper for workflow processing
+  WorkflowHelper: {
+    /**
+     * Create a workflow message
+     */
+    createMessage(opts) {
+      return {
+        workflow_id: opts.workflowId,
+        cookbook_name: opts.cookbookName,
+        step_index: opts.step || 0,
+        data: opts.data || {},
+        results: [],
+        timestamp: new Date().toISOString()
+      };
+    },
+
+    /**
+     * Parse a workflow message
+     */
+    parseMessage(message) {
+      return {
+        workflowId: message.workflow_id,
+        cookbookName: message.cookbook_name,
+        step: message.step_index,
+        data: message.data,
+        results: message.results
+      };
+    },
+
+    /**
+     * Get next queue from cookbook step
+     */
+    getNextQueue(step) {
+      if (step.queue) {
+        return step.queue;
+      }
+      return `${step.service}.queue`;
+    },
+
+    /**
+     * Validate workflow message
+     */
+    isValidMessage(message) {
+      return !!(message.workflow_id && message.cookbook_name &&
+                typeof message.step_index === 'number' && message.data);
+    },
+
+    /**
+     * Add result to workflow message
+     */
+    addResult(message, result) {
+      return {
+        ...message,
+        results: [...(message.results || []), result],
+        last_result: result
+      };
+    },
+
+    /**
+     * Create error message
+     */
+    createErrorMessage(message, error, serviceName) {
+      return {
+        ...message,
+        status: 'error',
+        error: {
+          message: error.message,
+          stack: error.stack,
+          service: serviceName,
+          step: message.step_index
+        }
+      };
+    },
+
+    /**
+     * Process a workflow step
+     * @param {Object} message - Workflow message
+     * @param {Function} handler - Step handler function
+     * @returns {Object} - Updated workflow message
+     */
+    async processStep(message, handler) {
+      const { workflow_id, current_step, cookbook, context = {} } = message;
+
+      // Get current step from cookbook
+      const step = cookbook?.steps?.[current_step];
+      if (!step) {
+        throw new Error(`Step ${current_step} not found in cookbook`);
+      }
+
+      // Execute handler
+      const result = await handler(step, context);
+
+      // Build response message
+      return {
+        ...message,
+        current_step: current_step + 1,
+        context: {
+          ...context,
+          [`step_${current_step}_result`]: result
+        },
+        trace: [
+          ...(message.trace || []),
+          {
+            step: current_step,
+            service: step.service,
+            timestamp: new Date().toISOString(),
+            result: result
+          }
+        ]
+      };
+    },
+
+    /**
+     * Determine next queue based on workflow state
+     * @param {Object} message - Workflow message
+     * @returns {string} - Next queue name
+     */
+    getNextQueueFromMessage(message) {
+      const { current_step, cookbook } = message;
+
+      if (cookbook && current_step < cookbook.steps.length) {
+        const nextStep = cookbook.steps[current_step];
+        return `${nextStep.service}.queue`;
+      }
+
+      return 'workflow.completed';
+    }
+  }
+};
+
+// For backward compatibility
+module.exports.ConnectorCore = module.exports;