feat(cli): log config import and validation steps

matejchalk · matejchalk · commit f3cebd3b7891 · 2025-12-09T09:51:02.000+01:00
diff --git a/packages/cli/src/lib/implementation/core-config.middleware.int.test.ts b/packages/cli/src/lib/implementation/core-config.middleware.int.test.ts
@@ -40,7 +40,7 @@ describe('coreConfigMiddleware', () => {
   it('should throw with invalid config path', async () => {
     await expect(
       coreConfigMiddleware({ config: 'wrong/path/to/config', ...CLI_DEFAULTS }),
-    ).rejects.toThrow(/Provided path .* is not valid./);
+    ).rejects.toThrow(/File '.*' does not exist/);
   });
 
   it('should load config which relies on provided --tsconfig', async () => {
diff --git a/packages/cli/src/lib/implementation/core-config.middleware.ts b/packages/cli/src/lib/implementation/core-config.middleware.ts
@@ -10,6 +10,7 @@ import {
   uploadConfigSchema,
   validate,
 } from '@code-pushup/models';
+import { logger, pluralizeToken } from '@code-pushup/utils';
 import type { CoreConfigCliOptions } from './core-config.model.js';
 import type { FilterOptions } from './filter.model.js';
 import type { GlobalOptions } from './global.model.js';
@@ -47,40 +48,45 @@ export async function coreConfigMiddleware<
     cache: cliCache,
     ...remainingCliOptions
   } = processArgs;
-  // Search for possible configuration file extensions if path is not given
-  const importedRc = config
-    ? await readRcByPath(config, tsconfig)
-    : await autoloadRc(tsconfig);
-  const {
-    persist: rcPersist,
-    upload: rcUpload,
-    ...remainingRcConfig
-  } = importedRc;
-  const upload =
-    rcUpload == null && cliUpload == null
-      ? undefined
-      : validate(uploadConfigSchema, { ...rcUpload, ...cliUpload });
 
-  return {
-    ...(config != null && { config }),
-    cache: normalizeCache(cliCache),
-    persist: buildPersistConfig(cliPersist, rcPersist),
-    ...(upload != null && { upload }),
-    ...remainingRcConfig,
-    ...remainingCliOptions,
-  };
+  return logger.group('Loading configuration', async () => {
+    // Search for possible configuration file extensions if path is not given
+    const importedRc = config
+      ? await readRcByPath(config, tsconfig)
+      : await autoloadRc(tsconfig);
+    const {
+      persist: rcPersist,
+      upload: rcUpload,
+      ...remainingRcConfig
+    } = importedRc;
+    const upload =
+      rcUpload == null && cliUpload == null
+        ? undefined
+        : validate(uploadConfigSchema, { ...rcUpload, ...cliUpload });
+
+    const result: GlobalOptions & CoreConfig & FilterOptions = {
+      ...(config != null && { config }),
+      cache: normalizeCache(cliCache),
+      persist: buildPersistConfig(cliPersist, rcPersist),
+      ...(upload != null && { upload }),
+      ...remainingRcConfig,
+      ...remainingCliOptions,
+    };
+
+    return {
+      message: `Parsed config: ${summarizeConfig(result)}`,
+      result,
+    };
+  });
 }
 
-export const normalizeBooleanWithNegation = <T extends string>(
-  propertyName: T,
-  cliOptions?: Record<T, unknown>,
-  rcOptions?: Record<T, unknown>,
-): boolean =>
-  propertyName in (cliOptions ?? {})
-    ? (cliOptions?.[propertyName] as boolean)
-    : `no-${propertyName}` in (cliOptions ?? {})
-      ? false
-      : ((rcOptions?.[propertyName] as boolean) ?? true);
+function summarizeConfig(config: CoreConfig): string {
+  return [
+    pluralizeToken('plugin', config.plugins.length),
+    pluralizeToken('category', config.categories?.length ?? 0),
+    `upload ${config.upload ? 'enabled' : 'disabled'}`,
+  ].join(', ');
+}
 
 export const normalizeCache = (cache?: CacheConfig): CacheConfigObject => {
   if (cache == null) {
diff --git a/packages/cli/src/lib/implementation/core-config.middleware.unit.test.ts b/packages/cli/src/lib/implementation/core-config.middleware.unit.test.ts
@@ -2,12 +2,11 @@ import { describe, expect, vi } from 'vitest';
 import { autoloadRc, readRcByPath } from '@code-pushup/core';
 import {
   coreConfigMiddleware,
-  normalizeBooleanWithNegation,
   normalizeFormats,
 } from './core-config.middleware.js';
 import type { CoreConfigCliOptions } from './core-config.model.js';
 import type { FilterOptions } from './filter.model.js';
-import type { GeneralCliOptions } from './global.model.js';
+import type { GlobalOptions } from './global.model.js';
 
 vi.mock('@code-pushup/core', async () => {
   const { CORE_CONFIG_MOCK }: typeof import('@code-pushup/test-utils') =
@@ -20,36 +19,6 @@ vi.mock('@code-pushup/core', async () => {
   };
 });
 
-describe('normalizeBooleanWithNegation', () => {
-  it('should return true when CLI property is true', () => {
-    expect(normalizeBooleanWithNegation('report', { report: true }, {})).toBe(
-      true,
-    );
-  });
-
-  it('should return false when CLI property is false', () => {
-    expect(normalizeBooleanWithNegation('report', { report: false }, {})).toBe(
-      false,
-    );
-  });
-
-  it('should return false when no-property exists in CLI persist', () => {
-    expect(
-      normalizeBooleanWithNegation('report', { 'no-report': true }, {}),
-    ).toBe(false);
-  });
-
-  it('should fallback to RC persist when no CLI property', () => {
-    expect(normalizeBooleanWithNegation('report', {}, { report: false })).toBe(
-      false,
-    );
-  });
-
-  it('should return default true when no property anywhere', () => {
-    expect(normalizeBooleanWithNegation('report', {}, {})).toBe(true);
-  });
-});
-
 describe('normalizeFormats', () => {
   it('should forward valid formats', () => {
     expect(normalizeFormats(['json', 'md'])).toEqual(['json', 'md']);
@@ -71,15 +40,15 @@ describe('normalizeFormats', () => {
 describe('coreConfigMiddleware', () => {
   it('should attempt to load code-pushup.config.(ts|mjs|js) by default', async () => {
     await coreConfigMiddleware(
-      {} as GeneralCliOptions & CoreConfigCliOptions & FilterOptions,
+      {} as GlobalOptions & CoreConfigCliOptions & FilterOptions,
     );
     expect(autoloadRc).toHaveBeenCalled();
   });
 
   it('should directly attempt to load passed config', async () => {
     await coreConfigMiddleware({
       config: 'cli/custom-config.mjs',
-    } as GeneralCliOptions & CoreConfigCliOptions & FilterOptions);
+    } as GlobalOptions & CoreConfigCliOptions & FilterOptions);
     expect(autoloadRc).not.toHaveBeenCalled();
     expect(readRcByPath).toHaveBeenCalledWith(
       'cli/custom-config.mjs',
@@ -90,15 +59,15 @@ describe('coreConfigMiddleware', () => {
   it('should forward --tsconfig option to config autoload', async () => {
     await coreConfigMiddleware({
       tsconfig: 'tsconfig.base.json',
-    } as GeneralCliOptions & CoreConfigCliOptions & FilterOptions);
+    } as GlobalOptions & CoreConfigCliOptions & FilterOptions);
     expect(autoloadRc).toHaveBeenCalledWith('tsconfig.base.json');
   });
 
   it('should forward --tsconfig option to custom config load', async () => {
     await coreConfigMiddleware({
       config: 'apps/website/code-pushup.config.ts',
       tsconfig: 'apps/website/tsconfig.json',
-    } as GeneralCliOptions & CoreConfigCliOptions & FilterOptions);
+    } as GlobalOptions & CoreConfigCliOptions & FilterOptions);
     expect(readRcByPath).toHaveBeenCalledWith(
       'apps/website/code-pushup.config.ts',
       'apps/website/tsconfig.json',
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
@@ -24,11 +24,7 @@ export {
   executePlugins,
 } from './lib/implementation/execute-plugin.js';
 export { persistReport } from './lib/implementation/persist.js';
-export {
-  autoloadRc,
-  ConfigPathError,
-  readRcByPath,
-} from './lib/implementation/read-rc-file.js';
+export { autoloadRc, readRcByPath } from './lib/implementation/read-rc-file.js';
 export { AuditOutputsMissingAuditError } from './lib/implementation/runner.js';
 export { mergeDiffs } from './lib/merge-diffs.js';
 export { upload, type UploadOptions } from './lib/upload.js';
diff --git a/packages/core/src/lib/implementation/read-rc-file.int.test.ts b/packages/core/src/lib/implementation/read-rc-file.int.test.ts
@@ -55,15 +55,13 @@ describe('readRcByPath', () => {
   });
 
   it('should throw if the path is empty', async () => {
-    await expect(readRcByPath('')).rejects.toThrow(
-      'The path to the configuration file is empty.',
-    );
+    await expect(readRcByPath('')).rejects.toThrow("File '' does not exist");
   });
 
   it('should throw if the file does not exist', async () => {
     await expect(
       readRcByPath(path.join('non-existent', 'config.file.js')),
-    ).rejects.toThrow(/Provided path .* is not valid./);
+    ).rejects.toThrow(/File '.*' does not exist/);
   });
 
   it('should throw if the configuration is empty', async () => {
diff --git a/packages/core/src/lib/implementation/read-rc-file.ts b/packages/core/src/lib/implementation/read-rc-file.ts
@@ -1,3 +1,4 @@
+import ansis from 'ansis';
 import path from 'node:path';
 import {
   CONFIG_FILE_NAME,
@@ -6,36 +7,45 @@ import {
   coreConfigSchema,
   validate,
 } from '@code-pushup/models';
-import { fileExists, importModule } from '@code-pushup/utils';
-
-export class ConfigPathError extends Error {
-  constructor(configPath: string) {
-    super(`Provided path '${configPath}' is not valid.`);
-  }
-}
+import { fileExists, importModule, logger } from '@code-pushup/utils';
 
 export async function readRcByPath(
   filePath: string,
   tsconfig?: string,
 ): Promise<CoreConfig> {
-  if (filePath.length === 0) {
-    throw new Error('The path to the configuration file is empty.');
-  }
-
-  if (!(await fileExists(filePath))) {
-    throw new ConfigPathError(filePath);
-  }
+  const formattedTarget = [
+    `${ansis.bold(path.relative(process.cwd(), filePath))}`,
+    tsconfig &&
+      `(paths from ${ansis.bold(path.relative(process.cwd(), tsconfig))})`,
+  ]
+    .filter(Boolean)
+    .join(' ');
 
-  const cfg: CoreConfig = await importModule({
-    filepath: filePath,
-    tsconfig,
-    format: 'esm',
-  });
+  const value = await logger.task(
+    `Importing config from ${formattedTarget}`,
+    async () => {
+      const result = await importModule({
+        filepath: filePath,
+        tsconfig,
+        format: 'esm',
+      });
+      return { result, message: `Imported config from ${formattedTarget}` };
+    },
+  );
 
-  return validate(coreConfigSchema, cfg, { filePath });
+  const config = validate(coreConfigSchema, value, { filePath });
+  logger.info('Configuration is valid ✓');
+  return config;
 }
 
 export async function autoloadRc(tsconfig?: string): Promise<CoreConfig> {
+  const configFilePatterns = [
+    CONFIG_FILE_NAME,
+    `{${SUPPORTED_CONFIG_FILE_FORMATS.join(',')}}`,
+  ].join('.');
+
+  logger.debug(`Looking for default config file ${configFilePatterns}`);
+
   // eslint-disable-next-line functional/no-let
   let ext = '';
   // eslint-disable-next-line functional/no-loop-statements
@@ -44,16 +54,15 @@ export async function autoloadRc(tsconfig?: string): Promise<CoreConfig> {
     const exists = await fileExists(filePath);
 
     if (exists) {
+      logger.debug(`Found default config file ${ansis.bold(filePath)}`);
       ext = extension;
       break;
     }
   }
 
   if (!ext) {
     throw new Error(
-      `No file ${CONFIG_FILE_NAME}.(${SUPPORTED_CONFIG_FILE_FORMATS.join(
-        '|',
-      )}) present in ${process.cwd()}`,
+      `No ${configFilePatterns} file present in ${process.cwd()}`,
     );
   }
 
diff --git a/packages/core/src/lib/implementation/read-rc-file.unit.test.ts b/packages/core/src/lib/implementation/read-rc-file.unit.test.ts
@@ -76,7 +76,7 @@ describe('autoloadRc', () => {
 
   it('should throw if no configuration file is present', async () => {
     await expect(autoloadRc()).rejects.toThrow(
-      'No file code-pushup.config.(ts|mjs|js) present in',
+      `No code-pushup.config.{ts,mjs,js} file present in ${MEMFS_VOLUME}`,
     );
   });
 });
diff --git a/packages/plugin-coverage/src/lib/nx/coverage-paths.unit.test.ts b/packages/plugin-coverage/src/lib/nx/coverage-paths.unit.test.ts
@@ -261,7 +261,9 @@ describe('getCoveragePathForJest', () => {
     vol.fromJSON(
       {
         // values come from bundle-require mock above
+        'jest-preset.config.ts': '',
         'jest-valid.config.unit.ts': '',
+        'jest-valid.config.integration.ts': '',
         'jest-no-dir.config.integration.ts': '',
         'jest-no-lcov.config.integration.ts': '',
       },
diff --git a/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts b/packages/plugin-lighthouse/src/lib/runner/utils.unit.test.ts
@@ -368,6 +368,7 @@ describe('getConfig', () => {
   });
 
   it('should load config from lh-config.js file if configPath is specified', async () => {
+    vol.fromJSON({ 'lh-config.js': '// mocked above' }, MEMFS_VOLUME);
     await expect(getConfig({ configPath: 'lh-config.js' })).resolves.toEqual(
       expect.objectContaining({
         upload: expect.objectContaining({
diff --git a/packages/utils/mocks/fixtures/invalid-js-file.json b/packages/utils/mocks/fixtures/invalid-js-file.json
@@ -0,0 +1 @@
+{ "key": "value" }
diff --git a/packages/utils/mocks/fixtures/valid-ts-default-export.ts b/packages/utils/mocks/fixtures/valid-ts-default-export.ts
@@ -0,0 +1 @@
+export default 'valid-ts-default-export';
diff --git a/packages/utils/src/lib/file-system.int.test.ts b/packages/utils/src/lib/file-system.int.test.ts
@@ -37,11 +37,31 @@ describe('importModule', () => {
     );
   });
 
-  it('should throw if the file does not exist', async () => {
+  it('should load a valid TS module with a default export', async () => {
     await expect(
       importModule({
-        filepath: 'path/to/non-existent-export.mjs',
+        filepath: path.join(mockDir, 'valid-ts-default-export.ts'),
       }),
-    ).rejects.toThrow('non-existent-export.mjs');
+    ).resolves.toBe('valid-ts-default-export');
+  });
+
+  it('should throw if the file does not exist', async () => {
+    await expect(
+      importModule({ filepath: 'path/to/non-existent-export.mjs' }),
+    ).rejects.toThrow("File 'path/to/non-existent-export.mjs' does not exist");
+  });
+
+  it('should throw if path is a directory', async () => {
+    await expect(importModule({ filepath: mockDir })).rejects.toThrow(
+      `Expected '${mockDir}' to be a file`,
+    );
+  });
+
+  it('should throw if file is not valid JS', async () => {
+    await expect(
+      importModule({ filepath: path.join(mockDir, 'invalid-js-file.json') }),
+    ).rejects.toThrow(
+      `${path.join(mockDir, 'invalid-js-file.json')} is not a valid JS file`,
+    );
   });
 });
diff --git a/packages/utils/src/lib/file-system.ts b/packages/utils/src/lib/file-system.ts
@@ -6,6 +6,7 @@ import type { Format, PersistConfig } from '@code-pushup/models';
 import { formatBytes } from './formatting.js';
 import { logMultipleResults } from './log-results.js';
 import { logger } from './logger.js';
+import { settlePromise } from './promises.js';
 
 export async function readTextFile(filePath: string): Promise<string> {
   const buffer = await readFile(filePath);
@@ -78,6 +79,14 @@ export function logMultipleFileResults(
 }
 
 export async function importModule<T = unknown>(options: Options): Promise<T> {
+  const resolvedStats = await settlePromise(stat(options.filepath));
+  if (resolvedStats.status === 'rejected') {
+    throw new Error(`File '${options.filepath}' does not exist`);
+  }
+  if (!resolvedStats.value.isFile()) {
+    throw new Error(`Expected '${options.filepath}' to be a file`);
+  }
+
   const { mod } = await bundleRequire<object>(options);
 
   if (typeof mod === 'object' && 'default' in mod) {
