@onlineapps/service-wrapper 2.0.59 → 2.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.59",
+  "version": "2.1.3",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -11,8 +11,7 @@
     "test:coverage": "jest --coverage",
     "test:mocked": "node test/run-tests.js",
     "docs": "jsdoc2md --files src/**/*.js > API.md",
-    "docs:html": "jsdoc -c jsdoc.json -d docs/html",
-    "prepublishOnly": "cd $(git rev-parse --show-toplevel) && bash scripts/pre-publish-compatibility-check.sh shared/connector/service-wrapper"
+    "docs:html": "jsdoc -c jsdoc.json -d docs/html"
   },
   "keywords": [
     "microservices",

package/src/ConfigLoader.js

@@ -0,0 +1,216 @@
+/**
+ * ConfigLoader - Unified configuration file loading for business services
+ *
+ * Single responsibility: Load all service configuration files
+ * from standardized locations with consistent error handling.
+ *
+ * CENTRAL REGISTRY of all configuration files:
+ * - conn-config/config.json        (REQUIRED) - Service configuration
+ * - conn-config/operations.json    (REQUIRED) - Operations specification
+ * - conn-runtime/validation-proof.json (OPTIONAL) - Pre-validation proof
+ *
+ * Usage:
+ *   const { ConfigLoader } = require('@onlineapps/service-wrapper');
+ *   const config = ConfigLoader.loadAll();
+ *
+ * Design principle: ONE place to define, validate, and load ALL configs.
+ * 
+ * @module @onlineapps/service-wrapper/ConfigLoader
+ * @since 2.1.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * CENTRAL REGISTRY: All configuration files used by business services
+ * If you add a new config file, add it here!
+ */
+const CONFIG_REGISTRY = {
+  SERVICE_CONFIG: {
+    path: 'conn-config/config.json',
+    required: true,
+    description: 'Service metadata and wrapper configuration'
+  },
+  OPERATIONS: {
+    path: 'conn-config/operations.json',
+    required: true,
+    description: 'Operations specification (API contract)'
+  },
+  VALIDATION_PROOF: {
+    path: 'conn-runtime/validation-proof.json',
+    required: false,
+    description: 'Pre-validation proof from cookbook tests'
+  }
+};
+
+class ConfigLoader {
+  /**
+   * Resolve environment variable substitution
+   * Supports format: ${VAR_NAME:default_value}
+   * @param {string} value - Value to resolve
+   * @returns {string} Resolved value
+   */
+  static resolveEnvVar(value) {
+    if (typeof value !== 'string') {
+      return value;
+    }
+
+    // Match ${VAR_NAME:default} or ${VAR_NAME}
+    const match = value.match(/^\$\{([^:}]+)(?::([^}]+))?\}$/);
+    if (!match) {
+      return value;
+    }
+
+    const varName = match[1];
+    const defaultValue = match[2];
+
+    return process.env[varName] || defaultValue || '';
+  }
+
+  /**
+   * Get list of all configuration files
+   * @returns {Object} Configuration registry
+   */
+  static getConfigRegistry() {
+    return CONFIG_REGISTRY;
+  }
+
+  /**
+   * Load service configuration from conn-config/config.json
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {Object} Service configuration
+   * @throws {Error} If config file not found or invalid JSON
+   */
+  static loadServiceConfig(basePath = process.cwd()) {
+    const configPath = path.join(basePath, 'conn-config', 'config.json');
+
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(content);
+
+      // Validate required fields
+      if (!config.service || !config.service.name || !config.service.version) {
+        throw new Error('Invalid config.json: Missing required fields (service.name, service.version)');
+      }
+
+      return config;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Service config not found: ${configPath}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Load operations specification from conn-config/operations.json
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {Object} Operations specification
+   * @throws {Error} If operations file not found or invalid
+   */
+  static loadOperations(basePath = process.cwd()) {
+    const operationsPath = path.join(basePath, 'conn-config', 'operations.json');
+
+    try {
+      const content = fs.readFileSync(operationsPath, 'utf8');
+      const operations = JSON.parse(content);
+
+      // Validate structure
+      if (!operations.operations || typeof operations.operations !== 'object') {
+        throw new Error('Invalid operations.json: Missing or invalid "operations" field');
+      }
+
+      return operations;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Operations specification not found: ${operationsPath}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Load validation proof from conn-runtime/validation-proof.json (optional)
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {Object|null} Validation proof or null if not found
+   */
+  static loadValidationProof(basePath = process.cwd()) {
+    const proofPath = path.join(basePath, 'conn-runtime', 'validation-proof.json');
+
+    try {
+      // Check existence first (non-critical file)
+      if (!fs.existsSync(proofPath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(proofPath, 'utf8');
+      const proof = JSON.parse(content);
+
+      // Validate structure
+      if (!proof.validationProof && !proof.hash) {
+        console.warn('[ConfigLoader] Invalid validation-proof.json structure - ignoring');
+        return null;
+      }
+
+      return {
+        hash: proof.validationProof || proof.hash,
+        data: proof.validationData || proof.data
+      };
+    } catch (error) {
+      // Non-critical - just log warning
+      console.warn(`[ConfigLoader] Failed to load validation proof: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Load all service configurations at once
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {Object} Combined configuration object
+   */
+  static loadAll(basePath = process.cwd()) {
+    const serviceConfig = this.loadServiceConfig(basePath);
+    const operations = this.loadOperations(basePath);
+    const validationProof = this.loadValidationProof(basePath);
+
+    // Resolve environment variables in port and url
+    const resolvedPort = this.resolveEnvVar(serviceConfig.service.port);
+    const resolvedUrl = this.resolveEnvVar(serviceConfig.service.url);
+
+    return {
+      service: {
+        name: serviceConfig.service.name,
+        version: serviceConfig.service.version,
+        port: parseInt(resolvedPort, 10),
+        url: resolvedUrl,
+        env: process.env.NODE_ENV || 'development'
+      },
+      wrapper: serviceConfig.wrapper || {},
+      operations,
+      validationProof
+    };
+  }
+
+  /**
+   * Get path to config directory
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {string} Absolute path to conn-config directory
+   */
+  static getConfigDir(basePath = process.cwd()) {
+    return path.join(basePath, 'conn-config');
+  }
+
+  /**
+   * Get path to specific config file
+   * @param {string} filename - Config filename
+   * @param {string} basePath - Base path (defaults to process.cwd())
+   * @returns {string} Absolute path to config file
+   */
+  static getConfigPath(filename, basePath = process.cwd()) {
+    return path.join(basePath, 'conn-config', filename);
+  }
+}
+
+module.exports = { ConfigLoader };
+

package/src/ServiceWrapper.js

@@ -530,17 +530,33 @@ class ServiceWrapper {
    */
   async _initializeMonitoring() {
     const serviceName = this.config.service?.name || 'unnamed-service';
+    const fs = require('fs');
+    const path = require('path');
+
+    // Ensure logs directory exists (standardized location: {serviceRoot}/logs/)
+    const logsDir = path.resolve(process.cwd(), 'logs');
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
+    }
 
     // Init returns API object with logger, info, error, warn, debug methods
     this.monitoring = await MonitoringConnector.init({
       serviceName,
+      // File logging configuration (enabled by default)
+      file: {
+        enabled: true,
+        directory: 'logs',
+        maxDays: 7,
+        filename: 'app.log',
+        ...(this.config.wrapper?.monitoring?.file || {})
+      },
       ...this.config.wrapper?.monitoring
     });
 
     // Logger is the API object returned from init (has logger, info, error, warn, debug)
     this.logger = this.monitoring;
     // Logger is now available, use it
-    this.logger.info('Monitoring connector initialized');
+    this.logger.info('Monitoring connector initialized', { logsDir });
 
     // Add monitoring middleware to Express app
     if (this.app) {
@@ -1254,13 +1270,10 @@ 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 || firstStepId
+          current_step: message.current_step || (message.cookbook?.steps?.[0]?.id)
         };
         
         // Validate normalized message has required fields

package/src/index.js

@@ -12,6 +12,7 @@
  */
 
 const ServiceWrapper = require('./ServiceWrapper');
+const { ConfigLoader } = require('./ConfigLoader');
 
 // Note: WorkflowProcessor and ApiCaller functionality has been moved to connectors:
 // - WorkflowProcessor -> @onlineapps/conn-orch-orchestrator
@@ -19,5 +20,6 @@ const ServiceWrapper = require('./ServiceWrapper');
 
 module.exports = ServiceWrapper;
 module.exports.ServiceWrapper = ServiceWrapper;
+module.exports.ConfigLoader = ConfigLoader;
 module.exports.default = ServiceWrapper;
-module.exports.VERSION = '2.0.0';
+module.exports.VERSION = '2.1.2';