feat: display used config path when logging level=log

packages/webpack-cli/__tests__/applyCLIPlugin.test.js

@@ -5,7 +5,7 @@ const applyCLIPlugin = new webpackCLI().applyCLIPlugin;
 
 describe('CLIPluginResolver', () => {
     it('should add CLI plugin to single compiler object', async () => {
-        const result = await applyCLIPlugin({ options: {} }, { hot: true, prefetch: true });
+        const result = await applyCLIPlugin({ options: {}, path: new WeakMap() }, { hot: true, prefetch: true });
         expect(result.options.plugins[0] instanceof CLIPlugin).toBeTruthy();
         expect(result.options.plugins[0].options).toEqual({
             configPath: undefined,
@@ -18,7 +18,7 @@ describe('CLIPluginResolver', () => {
     });
 
     it('should add CLI plugin to multi compiler object', async () => {
-        const result = await applyCLIPlugin({ options: [{}, {}] }, { hot: true, prefetch: true });
+        const result = await applyCLIPlugin({ options: [{}, {}], path: new WeakMap() }, { hot: true, prefetch: true });
         expect(result.options[0].plugins[0] instanceof CLIPlugin).toBeTruthy();
         expect(result.options[1].plugins[0] instanceof CLIPlugin).toBeTruthy();
         expect(result.options).toEqual([

packages/webpack-cli/lib/plugins/CLIPlugin.js

@@ -41,7 +41,12 @@ class CLIPlugin {
         const pluginName = 'webpack-cli';
         const getCompilationName = () => (compiler.name ? ` '${compiler.name}'` : '');
 
+        const { configPath } = this.options;
+
         compiler.hooks.run.tap(pluginName, () => {
+            if (configPath) {
+                this.logger.log(`Using config ${configPath}`);
+            }
             this.logger.log(`Compilation${getCompilationName()} starting...`);
         });
 
@@ -52,6 +57,10 @@ class CLIPlugin {
                 this.logger.warn('You are using "bail" with "watch". "bail" will still exit webpack when the first error is found.');
             }
 
+            if (configPath) {
+                this.logger.log(`Using config ${configPath}`);
+            }
+
             this.logger.log(`Compilation${getCompilationName()} starting...`);
         });
 

packages/webpack-cli/lib/webpack-cli.js

@@ -1631,7 +1631,7 @@ class WebpackCLI {
 
             configOptions.plugins.unshift(
                 new CLIPlugin({
-                    configPath: config.path,
+                    configPath: config.path.get(configOptions),
                     helpfulOutput: !cliOptions.json,
                     hot: cliOptions.hot,
                     progress: cliOptions.progress,

test/build/basic/basic.test.js

@@ -1,6 +1,6 @@
 'use strict';
-
-const { run } = require('../../utils/test-utils');
+const { resolve } = require('path');
+const { run, isWebpack5 } = require('../../utils/test-utils');
 
 describe('bundle command', () => {
     it('should work without command (default command)', async () => {
@@ -140,4 +140,14 @@ describe('bundle command', () => {
         expect(stderr).toContain("Run 'webpack --help' to see available commands and options");
         expect(stdout).toBeFalsy();
     });
+
+    it('should log supplied config when logging level is log', () => {
+        if (isWebpack5) {
+            const { exitCode, stderr, stdout } = run(__dirname, ['--config', './entry.config.js', '--infrastructure-logging-level', 'log']);
+            expect(exitCode).toBe(0);
+            const configPath = resolve(__dirname, './entry.config.js');
+            expect(stderr).toContain(`Using config ${configPath}`);
+            expect(stdout).toBeFalsy();
+        }
+    });
 });

test/core-flags/infrastructure-logging.test.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { run } = require('../utils/test-utils');
+const { resolve } = require('path');
 
 describe('infrastructure logging related flag', () => {
     it('should set infrastructureLogging.debug properly', () => {
@@ -27,4 +28,15 @@ describe('infrastructure logging related flag', () => {
         expect(stderr).toContain("Compilation 'compiler' finished");
         expect(stdout).toContain(`level: 'log'`);
     });
+
+    it('should log used default config when level is log', () => {
+        const { exitCode, stderr, stdout } = run(__dirname, ['--infrastructure-logging-level', 'log']);
+
+        expect(exitCode).toBe(0);
+        const configPath = resolve(__dirname, './webpack.config.js');
+        expect(stderr).toContain("Compilation 'compiler' starting...");
+        expect(stderr).toContain(`Using config ${configPath}`);
+        expect(stderr).toContain("Compilation 'compiler' finished");
+        expect(stdout).toContain(`level: 'log'`);
+    });
 });

test/serve/basic/serve-basic.test.js

@@ -329,4 +329,19 @@ describe('basic serve usage', () => {
         expect(stderr).toContain("Error: Unknown option '--unknown-flag'");
         expect(stdout).toBeFalsy();
     });
+
+    it('should log used supplied config with serve', async () => {
+        if (isWebpack5) {
+            const { stderr, stdout } = await runServe(__dirname, [
+                '--config',
+                'webpack.config.js',
+                '--infrastructure-logging-level',
+                'log',
+            ]);
+
+            const configPath = path.resolve(__dirname, './webpack.cache.config.js');
+            expect(stderr).toContain(`Using config ${configPath}`);
+            expect(stdout).toBeFalsy();
+        }
+    });
 });

test/watch/basic/basic.test.js

@@ -176,4 +176,20 @@ describe('basic', () => {
         expect(stderr).toContain("Run 'webpack --help' to see available commands and options");
         expect(stdout).toBeFalsy();
     });
+
+    it('should log supplied config with watch', async () => {
+        if (isWebpack5) {
+            const { stderr, stdout } = await run(__dirname, [
+                'watch',
+                '--config',
+                'watch.config.js',
+                '--infrastructure-logging-level',
+                'log',
+            ]);
+
+            const configPath = resolve(__dirname, './watch.config.js');
+            expect(stderr).toContain(`Using config ${configPath}`);
+            expect(stdout).toBeFalsy();
+        }
+    });
 });