better logging in config sources for debugging

Author: clavery

packages/b2c-tooling-sdk/src/cli/config.ts

@@ -117,6 +117,14 @@ export function loadConfig(
     sourcesAfter: pluginSources.after,
   });
 
+  // Log source summary
+  for (const source of resolved.sources) {
+    logger.trace(
+      {source: source.name, path: source.path, fields: source.fieldsContributed},
+      `[${source.name}] Contributed fields`,
+    );
+  }
+
   // Log warnings
   for (const warning of resolved.warnings) {
     logger.trace({warning}, `[Config] ${warning.message}`);

packages/b2c-tooling-sdk/src/config/dw-json.ts

@@ -14,6 +14,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import type {AuthMethod} from '../auth/types.js';
+import {getLogger} from '../logging/logger.js';
 
 /**
  * Configuration structure matching dw.json file format.
@@ -114,35 +115,58 @@ export function findDwJson(startDir: string = process.cwd()): string | undefined
  * 3. Root-level config
  */
 function selectConfig(json: DwJsonMultiConfig, instanceName?: string): DwJsonConfig {
+  const logger = getLogger();
+
   // Single config or no configs array
   if (!Array.isArray(json.configs) || json.configs.length === 0) {
+    logger.trace(
+      {selection: 'root', instanceName: json.name},
+      `[DwJsonSource] Selected config "${json.name ?? 'root'}" (single config)`,
+    );
     return json;
   }
 
   // Find by instance name
   if (instanceName) {
     // Check root first
     if (json.name === instanceName) {
+      logger.trace(
+        {selection: 'named', instanceName},
+        `[DwJsonSource] Selected config "${instanceName}" by name (root)`,
+      );
       return json;
     }
     // Then check configs array
     const found = json.configs.find((c) => c.name === instanceName);
     if (found) {
+      logger.trace({selection: 'named', instanceName}, `[DwJsonSource] Selected config "${instanceName}" by name`);
       return found;
     }
     // Instance not found, fall through to other selection methods
+    logger.trace(
+      {requestedInstance: instanceName},
+      `[DwJsonSource] Named instance "${instanceName}" not found, falling back`,
+    );
   }
 
   // Find active config
   if (json.active === false) {
     // Root is inactive, look for active in configs
     const activeConfig = json.configs.find((c) => c.active === true);
     if (activeConfig) {
+      logger.trace(
+        {selection: 'active', instanceName: activeConfig.name},
+        `[DwJsonSource] Selected config "${activeConfig.name}" by active flag`,
+      );
       return activeConfig;
     }
   }
 
   // Default to root config
+  logger.trace(
+    {selection: 'root', instanceName: json.name},
+    `[DwJsonSource] Selected config "${json.name ?? 'root'}" (default to root)`,
+  );
   return json;
 }
 
@@ -171,19 +195,26 @@ function selectConfig(json: DwJsonMultiConfig, instanceName?: string): DwJsonCon
  * const config = loadDwJson({ path: './config/dw.json' });
  */
 export function loadDwJson(options: LoadDwJsonOptions = {}): DwJsonConfig | undefined {
+  const logger = getLogger();
+
   // If explicit path provided, use it. Otherwise default to ./dw.json (no upward search)
   const dwJsonPath = options.path ?? path.join(options.startDir || process.cwd(), 'dw.json');
 
+  logger.trace({path: dwJsonPath}, '[DwJsonSource] Checking for config file');
+
   if (!fs.existsSync(dwJsonPath)) {
+    logger.trace({path: dwJsonPath}, '[DwJsonSource] No config file found');
     return undefined;
   }
 
   try {
     const content = fs.readFileSync(dwJsonPath, 'utf8');
     const json = JSON.parse(content) as DwJsonMultiConfig;
     return selectConfig(json, options.instance);
-  } catch {
+  } catch (error) {
     // Invalid JSON or read error
+    const message = error instanceof Error ? error.message : String(error);
+    logger.trace({path: dwJsonPath, error: message}, '[DwJsonSource] Failed to parse config file');
     return undefined;
   }
 }

packages/b2c-tooling-sdk/src/config/sources/dw-json-source.ts

@@ -10,19 +10,23 @@
  */
 import * as path from 'node:path';
 import {loadDwJson} from '../dw-json.js';
+import {getPopulatedFields} from '../mapping.js';
 import {mapDwJsonToNormalizedConfig} from '../mapping.js';
 import type {ConfigSource, NormalizedConfig, ResolveConfigOptions} from '../types.js';
+import {getLogger} from '../../logging/logger.js';
 
 /**
  * Configuration source that loads from dw.json files.
  *
  * @internal
  */
 export class DwJsonSource implements ConfigSource {
-  readonly name = 'dw.json';
+  readonly name = 'DwJsonSource';
   private lastPath?: string;
 
   load(options: ResolveConfigOptions): NormalizedConfig | undefined {
+    const logger = getLogger();
+
     const dwConfig = loadDwJson({
       instance: options.instance,
       path: options.configPath,
@@ -37,7 +41,12 @@ export class DwJsonSource implements ConfigSource {
     // Track the path for diagnostics - use explicit path or default location
     this.lastPath = options.configPath ?? path.join(options.startDir || process.cwd(), 'dw.json');
 
-    return mapDwJsonToNormalizedConfig(dwConfig);
+    const normalized = mapDwJsonToNormalizedConfig(dwConfig);
+    const fields = getPopulatedFields(normalized);
+
+    logger.trace({path: this.lastPath, fields}, '[DwJsonSource] Loaded config');
+
+    return normalized;
   }
 
   getPath(): string | undefined {

packages/b2c-tooling-sdk/src/config/sources/mobify-source.ts

@@ -12,6 +12,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import type {ConfigSource, NormalizedConfig, ResolveConfigOptions} from '../types.js';
+import {getLogger} from '../../logging/logger.js';
 
 /**
  * Mobify config file structure (~/.mobify)
@@ -37,15 +38,20 @@ interface MobifyConfigFile {
  * @internal
  */
 export class MobifySource implements ConfigSource {
-  readonly name = 'mobify';
+  readonly name = 'MobifySource';
   private lastPath?: string;
 
   load(options: ResolveConfigOptions): NormalizedConfig | undefined {
+    const logger = getLogger();
+
     // Use explicit credentialsFile if provided, otherwise use default path
     const mobifyPath = options.credentialsFile ?? this.getMobifyPath(options.cloudOrigin);
     this.lastPath = mobifyPath;
 
+    logger.trace({path: mobifyPath}, '[MobifySource] Checking for credentials file');
+
     if (!fs.existsSync(mobifyPath)) {
+      logger.trace({path: mobifyPath}, '[MobifySource] No credentials file found');
       return undefined;
     }
 
@@ -54,14 +60,19 @@ export class MobifySource implements ConfigSource {
       const config = JSON.parse(content) as MobifyConfigFile;
 
       if (!config.api_key) {
+        logger.trace({path: mobifyPath}, '[MobifySource] Credentials file found but no api_key present');
         return undefined;
       }
 
+      logger.trace({path: mobifyPath, fields: ['mrtApiKey']}, '[MobifySource] Loaded credentials');
+
       return {
         mrtApiKey: config.api_key,
       };
-    } catch {
+    } catch (error) {
       // Invalid JSON or read error
+      const message = error instanceof Error ? error.message : String(error);
+      logger.trace({path: mobifyPath, error: message}, '[MobifySource] Failed to parse credentials file');
       return undefined;
     }
   }

packages/b2c-tooling-sdk/src/config/types.ts

@@ -64,7 +64,7 @@ export interface NormalizedConfig {
   mrtOrigin?: string;
 
   // Metadata
-  /** Instance name (from multi-config dw.json) */
+  /** Instance name (from multi-config supporting sources) */
   instanceName?: string;
 }
 
@@ -113,7 +113,7 @@ export interface ConfigResolutionResult {
  * Options for configuration resolution.
  */
 export interface ResolveConfigOptions {
-  /** Named instance from dw.json "configs" array */
+  /** Named instance for supporting ConfigSources */
   instance?: string;
   /** Explicit path to config file (defaults to auto-discover) */
   configPath?: string;

packages/b2c-tooling-sdk/test/config/sources.test.ts

@@ -126,7 +126,7 @@ describe('config/sources', () => {
       resolver.resolve();
       const {sources} = resolver.resolve();
 
-      const dwJsonSource = sources.find((s) => s.name === 'dw.json');
+      const dwJsonSource = sources.find((s) => s.name === 'DwJsonSource');
       // Normalize paths to handle macOS symlinks (/var -> /private/var)
       const expectedPath = fs.realpathSync(dwJsonPath);
       const actualPath = dwJsonSource?.path ? fs.realpathSync(dwJsonSource.path) : undefined;
@@ -346,7 +346,7 @@ describe('config/sources', () => {
         resolver.resolve();
         const {sources} = resolver.resolve();
 
-        const mobifySource = sources.find((s) => s.name === 'mobify');
+        const mobifySource = sources.find((s) => s.name === 'MobifySource');
         // Normalize paths to handle macOS symlinks
         const expectedPath = fs.realpathSync(mobifyPath);
         const actualPath = mobifySource?.path ? fs.realpathSync(mobifySource.path) : undefined;