@onlineapps/service-wrapper 2.1.116 → 2.1.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.1.116",
+  "version": "2.1.118",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -32,7 +32,7 @@
     "@onlineapps/conn-orch-cookbook": "2.0.35",
     "@onlineapps/conn-orch-orchestrator": "1.0.103",
     "@onlineapps/conn-orch-registry": "1.1.52",
-    "@onlineapps/conn-orch-validator": "2.0.29",
+    "@onlineapps/conn-orch-validator": "2.0.30",
     "@onlineapps/monitoring-core": "1.0.21",
     "@onlineapps/service-common": "1.0.17",
     "@onlineapps/runtime-config": "1.0.2"

package/src/ConfigLoader.js

@@ -27,26 +27,48 @@ const runtimeCfg = require('./config');
 /**
  * CENTRAL REGISTRY: All configuration files used by business services
  * If you add a new config file, add it here!
+ *
+ * Path resolution order (first found wins):
+ *   1. config/service/  (new standard)
+ *   2. conn-config/     (legacy, backward compat)
  */
 const CONFIG_REGISTRY = {
   SERVICE_CONFIG: {
-    path: 'conn-config/config.json',
+    paths: ['config/service/config.json', 'conn-config/config.json'],
     required: true,
     description: 'Service metadata and wrapper configuration'
   },
   OPERATIONS: {
-    path: 'conn-config/operations.json',
+    paths: ['config/service/operations.json', 'conn-config/operations.json'],
     required: true,
     description: 'Operations specification (API contract)'
   },
   VALIDATION_PROOF: {
-    path: 'conn-runtime/validation-proof.json',
+    paths: ['config/runtime/validation-proof.json', 'conn-runtime/validation-proof.json'],
     required: false,
     description: 'Pre-validation proof from cookbook tests'
   }
 };
 
 class ConfigLoader {
+  /**
+   * Resolve a config file from an ordered list of candidate paths.
+   * Returns the first path that exists, or null if none found.
+   * @param {string[]} candidatePaths - Relative paths to try (first found wins)
+   * @param {string} basePath - Service root directory
+   * @returns {string|null} Absolute path to the first existing file, or null
+   * @private
+   */
+  static _resolveConfigPath(candidatePaths, basePath) {
+    for (const relPath of candidatePaths) {
+      const abs = path.join(basePath, relPath);
+      if (fs.existsSync(abs)) {
+        return abs;
+      }
+    }
+    return null;
+  }
+
   /**
    * Ensure env is provided for placeholder resolution.
    * @param {any} env
@@ -194,21 +216,25 @@ class ConfigLoader {
    */
   static loadServiceConfig(options = {}) {
     const { basePath = process.cwd(), env } = options;
-    const configPath = path.join(basePath, 'conn-config', 'config.json');
+    const reg = CONFIG_REGISTRY.SERVICE_CONFIG;
+    const configPath = this._resolveConfigPath(reg.paths, basePath);
+
+    if (!configPath) {
+      throw new Error(
+        `[ConfigLoader] Service config not found - tried: ${reg.paths.map(p => path.join(basePath, p)).join(', ')}`
+      );
+    }
 
     try {
       const content = fs.readFileSync(configPath, 'utf8');
       const config = JSON.parse(content);
 
-      // Validate required fields (version not required - comes from package.json)
       if (!config.service || !config.service.name) {
         throw new Error('Invalid config.json: Missing required field (service.name)');
       }
 
-      // Always use version from package.json (Single Source of Truth)
       config.service.version = this.loadPackageVersion(basePath);
 
-      // Resolve env placeholders across the whole config (service + wrapper + custom sections)
       try {
         return this.resolveEnvPlaceholdersDeep(config, { jsonPath: '$', env });
       } catch (err) {
@@ -216,7 +242,7 @@ class ConfigLoader {
       }
     } catch (error) {
       if (error.code === 'ENOENT') {
-        throw new Error(`Service config not found: ${configPath}`);
+        throw new Error(`[ConfigLoader] Service config not found: ${configPath}`);
       }
       throw error;
     }
@@ -229,13 +255,19 @@ class ConfigLoader {
    * @throws {Error} If operations file not found or invalid
    */
   static loadOperations(basePath = process.cwd()) {
-    const operationsPath = path.join(basePath, 'conn-config', 'operations.json');
+    const reg = CONFIG_REGISTRY.OPERATIONS;
+    const operationsPath = this._resolveConfigPath(reg.paths, basePath);
+
+    if (!operationsPath) {
+      throw new Error(
+        `[ConfigLoader] Operations specification not found - tried: ${reg.paths.map(p => path.join(basePath, p)).join(', ')}`
+      );
+    }
 
     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');
       }
@@ -243,7 +275,7 @@ class ConfigLoader {
       return operations;
     } catch (error) {
       if (error.code === 'ENOENT') {
-        throw new Error(`Operations specification not found: ${operationsPath}`);
+        throw new Error(`[ConfigLoader] Operations specification not found: ${operationsPath}`);
       }
       throw error;
     }
@@ -255,18 +287,17 @@ class ConfigLoader {
    * @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');
+    const reg = CONFIG_REGISTRY.VALIDATION_PROOF;
+    const proofPath = this._resolveConfigPath(reg.paths, basePath);
 
-    try {
-      // Check existence first (non-critical file)
-      if (!fs.existsSync(proofPath)) {
-        return null;
-      }
+    if (!proofPath) {
+      return null;
+    }
 
+    try {
       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;
@@ -277,7 +308,6 @@ class ConfigLoader {
         data: proof.validationData || proof.data
       };
     } catch (error) {
-      // Non-critical - just log warning
       console.warn(`[ConfigLoader] Failed to load validation proof: ${error.message}`);
       return null;
     }
@@ -327,10 +357,9 @@ class ConfigLoader {
       customSections[k] = v;
     }
 
-    // FAIL-FAST: specificationEndpoint is REQUIRED (no fallbacks)
     if (!serviceConfig.service.specificationEndpoint) {
       throw new Error(
-        `[ConfigLoader] Missing required field - "specificationEndpoint" is required in conn-config/config.json under "service" section. ` +
+        `[ConfigLoader] Missing required field - "specificationEndpoint" is required in config/service/config.json (or conn-config/config.json) under "service" section. ` +
         `Fix: Add "specificationEndpoint": "/api/v1/specification" to config.json`
       );
     }
@@ -353,21 +382,29 @@ class ConfigLoader {
   }
 
   /**
-   * Get path to config directory
+   * Get path to config directory (prefers config/service/, falls back to conn-config/)
    * @param {string} basePath - Base path (defaults to process.cwd())
-   * @returns {string} Absolute path to conn-config directory
+   * @returns {string} Absolute path to config directory
    */
   static getConfigDir(basePath = process.cwd()) {
+    const newPath = path.join(basePath, 'config', 'service');
+    if (fs.existsSync(newPath)) {
+      return newPath;
+    }
     return path.join(basePath, 'conn-config');
   }
 
   /**
-   * Get path to specific config file
+   * Get path to specific config file (prefers config/service/, falls back to conn-config/)
    * @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()) {
+    const newPath = path.join(basePath, 'config', 'service', filename);
+    if (fs.existsSync(newPath)) {
+      return newPath;
+    }
     return path.join(basePath, 'conn-config', filename);
   }
 }