feat: merge configuration policies (#1264)

* feat: merge configuration policies

* feat: merge more fields from params

* chore: update types

* chore: remove unless code

* chore: add api example

* chore: update config resolve

* chore: remove example

---------

Co-authored-by: ADNY <66500121+ErKeLost@users.noreply.github.com>
Co-authored-by: erkelost <1256029807@qq.com>

Author: shulandmimi

.changeset/famous-llamas-suffer.md

@@ -0,0 +1,6 @@
+---
+'@farmfe/core': patch
+'@farmfe/cli': patch
+---
+
+merge configuration policies

packages/cli/src/config.ts

@@ -0,0 +1,40 @@
+import { FarmCLIOptions, UserConfig } from '@farmfe/core';
+import { FarmCLIBuildOptions, GlobalFarmCLIOptions } from './types.js';
+
+export function getOptionFromBuildOption(
+  options: FarmCLIBuildOptions & GlobalFarmCLIOptions
+): FarmCLIOptions & UserConfig {
+  const {
+    input,
+    outDir,
+    target,
+    format,
+    watch,
+    minify,
+    sourcemap,
+    treeShaking,
+    mode
+  } = options;
+
+  const output: UserConfig['compilation']['output'] = {
+    ...(outDir && { path: outDir }),
+    ...(target && { targetEnv: target }),
+    ...(format && { format })
+  };
+
+  const compilation: UserConfig['compilation'] = {
+    input: { ...(input && { index: input }) },
+    output,
+    ...(watch && { watch }),
+    ...(minify && { minify }),
+    ...(sourcemap && { sourcemap }),
+    ...(treeShaking && { treeShaking })
+  };
+
+  const defaultOptions: FarmCLIOptions & UserConfig = {
+    compilation,
+    ...(mode && { mode })
+  };
+
+  return defaultOptions;
+}

packages/cli/src/index.ts

@@ -3,14 +3,12 @@ import { readFileSync } from 'node:fs';
 import { cac } from 'cac';
 import {
   resolveCore,
-  getConfigPath,
   resolveCommandOptions,
   handleAsyncOperationErrors,
   preventExperimentalWarning,
-  resolveRootPath,
   resolveCliConfig
 } from './utils.js';
-import { COMMANDS } from './plugin/index.js';
+import { getOptionFromBuildOption } from './config.js';
 
 import type {
   FarmCLIBuildOptions,
@@ -97,22 +95,8 @@ cli
 
       const defaultOptions = {
         root,
-        compilation: {
-          watch: options.watch,
-          output: {
-            path: options?.outDir,
-            targetEnv: options?.target,
-            format: options?.format
-          },
-          input: {
-            index: options?.input
-          },
-          sourcemap: options.sourcemap,
-          minify: options.minify,
-          treeShaking: options.treeShaking
-        },
-        mode: options.mode,
-        configPath
+        configPath,
+        ...getOptionFromBuildOption(options)
       };
 
       const { build } = await resolveCore();
@@ -138,21 +122,8 @@ cli
 
       const defaultOptions = {
         root,
-        compilation: {
-          output: {
-            path: options?.outDir,
-            targetEnv: options?.target,
-            format: options?.format
-          },
-          input: {
-            index: options?.input
-          },
-          sourcemap: options.sourcemap,
-          minify: options.minify,
-          treeShaking: options.treeShaking
-        },
-        mode: options.mode,
-        configPath
+        configPath,
+        ...getOptionFromBuildOption(options)
       };
 
       const { watch } = await resolveCore();
@@ -211,24 +182,6 @@ cli
     }
   });
 
-// create plugins command
-cli
-  .command('plugin [command]', 'Commands for manage plugins', {
-    allowUnknownOptions: true
-  })
-  .action(async (command: keyof typeof COMMANDS, args: unknown) => {
-    try {
-      COMMANDS[command](args);
-    } catch (e) {
-      const { Logger } = await import('@farmfe/core');
-      const logger = new Logger();
-      logger.error(
-        `The command arg parameter is incorrect. If you want to create a plugin in farm. such as "farm plugin create"\n${e.stack}`
-      );
-      process.exit(1);
-    }
-  });
-
 // Listening for unknown command
 cli.on('command:*', async () => {
   const { Logger } = await import('@farmfe/core');

packages/cli/src/plugin/build.ts

@@ -45,7 +45,6 @@ import { traceDependencies } from '../utils/trace-dependencies.js';
 import type {
   Alias,
   FarmCLIOptions,
-  FarmCLIServerOptions,
   NormalizedServerConfig,
   ResolvedUserConfig,
   UserConfig,
@@ -57,6 +56,7 @@ import type {
 import { normalizeExternal } from './normalize-config/normalize-external.js';
 import { DEFAULT_CONFIG_NAMES, FARM_DEFAULT_NAMESPACE } from './constants.js';
 import merge from '../utils/merge.js';
+import { mergeConfig, mergeFarmCliConfig } from './mergeConfig.js';
 
 export * from './types.js';
 
@@ -73,23 +73,18 @@ export function defineFarmConfig(config: UserConfigExport): UserConfigExport {
 }
 
 async function getDefaultConfig(
+  config: UserConfig,
   inlineOptions: FarmCLIOptions,
   logger: Logger,
-  mode?: CompilationMode,
-  isHandleServerPortConflict = true
+  mode?: CompilationMode
 ) {
-  const mergedUserConfig = mergeInlineCliOptions({}, inlineOptions);
-
   const resolvedUserConfig = await resolveMergedUserConfig(
-    mergedUserConfig,
+    config,
     undefined,
     inlineOptions.mode ?? mode
   );
-  resolvedUserConfig.server = normalizeDevServerOptions({}, mode);
 
-  if (isHandleServerPortConflict) {
-    await handleServerPortConflict(resolvedUserConfig, logger, mode);
-  }
+  resolvedUserConfig.server = normalizeDevServerOptions({}, mode);
 
   resolvedUserConfig.compilation = await normalizeUserCompilationConfig(
     resolvedUserConfig,
@@ -122,7 +117,7 @@ async function handleServerPortConflict(
  * @param configPath
  */
 export async function resolveConfig(
-  inlineOptions: FarmCLIOptions,
+  inlineOptions: FarmCLIOptions & UserConfig,
   logger: Logger,
   mode?: CompilationMode,
   isHandleServerPortConflict = true
@@ -132,38 +127,36 @@ export async function resolveConfig(
   inlineOptions.mode = inlineOptions.mode ?? mode;
 
   // configPath may be file or directory
-  const { configPath } = inlineOptions;
-  // if the config file can not found, just merge cli options and return default
-  if (!configPath) {
-    return getDefaultConfig(
-      inlineOptions,
-      logger,
-      mode,
-      isHandleServerPortConflict
-    );
-  }
-
-  if (!path.isAbsolute(configPath)) {
-    throw new Error('configPath must be an absolute path');
-  }
+  let { configPath } = inlineOptions;
+  let rawConfig: UserConfig = mergeFarmCliConfig(inlineOptions, {});
 
-  const loadedUserConfig = await loadConfigFile(
-    configPath,
-    inlineOptions,
-    logger,
-    mode
-  );
+  // if the config file can not found, just merge cli options and return default
+  if (configPath) {
+    if (!path.isAbsolute(configPath)) {
+      throw new Error('configPath must be an absolute path');
+    }
 
-  if (!loadedUserConfig) {
-    return getDefaultConfig(
+    const loadedUserConfig = await loadConfigFile(
+      configPath,
       inlineOptions,
       logger,
-      mode,
-      isHandleServerPortConflict
+      mode
+    );
+    if (loadedUserConfig) {
+      configPath = loadedUserConfig.configFilePath;
+      rawConfig = mergeConfig(rawConfig, loadedUserConfig.config);
+    }
+  } else {
+    mergeConfig(
+      rawConfig,
+      await getDefaultConfig(rawConfig, inlineOptions, logger, mode)
     );
   }
 
-  const { config: userConfig, configFilePath } = loadedUserConfig;
+  const { config: userConfig, configFilePath } = {
+    configFilePath: configPath,
+    config: rawConfig
+  };
 
   const { jsPlugins, rustPlugins } = await resolveFarmPlugins(userConfig);
 
@@ -190,7 +183,7 @@ export async function resolveConfig(
 
   const config = await resolveConfigHook(userConfig, sortFarmJsPlugins);
 
-  const mergedUserConfig = mergeInlineCliOptions(config, inlineOptions);
+  const mergedUserConfig = mergeFarmCliConfig(inlineOptions, config);
 
   const resolvedUserConfig = await resolveMergedUserConfig(
     mergedUserConfig,
@@ -619,10 +612,10 @@ async function readConfigFile(
       '.farm'
     );
 
-    const fileName = `farm.config.bundle-{${Date.now()}-${Math.random()
+    const fileName = `farm.config.bundle-${Date.now()}-${Math.random()
       .toString(16)
       .split('.')
-      .join('')}}.mjs`;
+      .join('')}.mjs`;
 
     const normalizedConfig = await normalizeUserCompilationConfig(
       {
@@ -770,83 +763,7 @@ function checkClearScreen(inlineConfig: FarmCLIOptions) {
   }
 }
 
-function mergeInlineCliOptions(
-  userConfig: UserConfig,
-  inlineOptions: FarmCLIOptions
-): UserConfig {
-  const configRootPath = userConfig.root;
-  if (inlineOptions.root) {
-    const cliRoot = inlineOptions.root;
-
-    if (!isAbsolute(cliRoot)) {
-      userConfig.root = path.resolve(process.cwd(), cliRoot);
-    } else {
-      userConfig.root = cliRoot;
-    }
-  }
-
-  if (configRootPath) {
-    userConfig.root = configRootPath;
-  }
-
-  if (userConfig.root && !isAbsolute(userConfig.root)) {
-    const resolvedRoot = path.resolve(
-      inlineOptions.configPath,
-      userConfig.root
-    );
-    userConfig.root = resolvedRoot;
-  }
-
-  // set compiler options
-  ['minify', 'sourcemap'].forEach((option: keyof FarmCLIOptions) => {
-    if (inlineOptions[option] !== undefined) {
-      userConfig.compilation = {
-        ...(userConfig.compilation ?? {}),
-        [option]: inlineOptions[option]
-      };
-    }
-  });
-
-  const outputOptions = inlineOptions.compilation?.output;
-
-  if (outputOptions?.path) {
-    userConfig.compilation = {
-      ...(userConfig.compilation ?? {})
-    };
-
-    userConfig.compilation.output = {
-      ...(userConfig.compilation.output ?? {}),
-      path: outputOptions?.path
-    };
-  }
-
-  if (outputOptions?.targetEnv) {
-    userConfig.compilation = {
-      ...(userConfig.compilation ?? {})
-    };
-
-    userConfig.compilation.output = {
-      ...(userConfig.compilation.output ?? {}),
-      targetEnv: outputOptions?.targetEnv
-    };
-  }
-
-  // set server options
-  ['port', 'open', 'https', 'hmr', 'host', 'strictPort'].forEach(
-    (option: keyof FarmCLIServerOptions) => {
-      if (inlineOptions.server?.[option]) {
-        userConfig.server = {
-          ...(userConfig.server ?? {}),
-          [option]: inlineOptions.server[option]
-        };
-      }
-    }
-  );
-
-  return userConfig;
-}
-
-async function resolveMergedUserConfig(
+export async function resolveMergedUserConfig(
   mergedUserConfig: UserConfig,
   configFilePath: string | undefined,
   mode: 'development' | 'production' | string

packages/cli/src/plugin/create.ts

@@ -0,0 +1,137 @@
+import path, { isAbsolute } from 'node:path';
+import { isString } from '../plugin/js/utils.js';
+import { isArray, isObject } from '../utils/share.js';
+import { FarmCLIOptions, UserConfig } from './types.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mergeConfig<T extends Record<string, any>>(
+  userConfig: T,
+  target: T
+): T {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const result: Record<string, any> = { ...userConfig };
+  for (const key of Object.keys(target)) {
+    const left = result[key];
+    const right = target[key];
+
+    if (right === null || right === undefined) {
+      continue;
+    }
+
+    if (left === null || right === undefined) {
+      result[key] = right;
+      continue;
+    }
+
+    if (isArray(left) || isArray(right)) {
+      result[key] = [
+        ...(isArray(left) ? left : []),
+        ...(isArray(right) ? right : [])
+      ];
+      continue;
+    }
+
+    if (isObject(left) && isObject(right)) {
+      result[key] = mergeConfig(left, right);
+      continue;
+    }
+
+    result[key] = right;
+  }
+
+  return result as T;
+}
+
+export function mergeFarmCliConfig(
+  cliOption: FarmCLIOptions & UserConfig,
+  target: UserConfig
+): UserConfig {
+  let left: UserConfig = {};
+
+  (
+    [
+      'clearScreen',
+      'compilation',
+      'envDir',
+      'envPrefix',
+      'plugins',
+      'publicDir',
+      'server',
+      'vitePlugins'
+    ] satisfies (keyof UserConfig)[]
+  ).forEach((key) => {
+    const value = cliOption[key];
+    if (value || typeof value === 'boolean') {
+      left = mergeConfig(left, { [key]: cliOption[key] });
+    }
+  });
+
+  {
+    // root
+    const configRootPath = target.root;
+
+    if (cliOption.root) {
+      const cliRoot = cliOption.root;
+
+      if (!isAbsolute(cliRoot)) {
+        target.root = path.resolve(process.cwd(), cliRoot);
+      } else {
+        target.root = cliRoot;
+      }
+    }
+    if (configRootPath) {
+      target.root = configRootPath;
+    }
+
+    if (target.root && !isAbsolute(target.root)) {
+      const resolvedRoot = path.resolve(cliOption.configPath, target.root);
+      target.root = resolvedRoot;
+    }
+  }
+
+  if (isString(cliOption.host) || typeof cliOption.host === 'boolean') {
+    left = mergeConfig(left, { server: { host: cliOption.host } });
+  }
+
+  if (typeof cliOption.minify === 'boolean') {
+    left = mergeConfig(left, { compilation: { minify: cliOption.minify } });
+  }
+
+  if (cliOption.outDir) {
+    left = mergeConfig(left, {
+      compilation: { output: { path: cliOption.outDir } }
+    });
+  }
+
+  if (cliOption.port) {
+    left = mergeConfig(left, {
+      server: {
+        port: cliOption.port
+      }
+    });
+  }
+
+  if (cliOption.mode) {
+    left = mergeConfig(left, {
+      compilation: {
+        mode: cliOption.mode as UserConfig['compilation']['mode']
+      }
+    });
+  }
+
+  if (cliOption.https) {
+    left = mergeConfig(left, {
+      server: {
+        https: cliOption.https
+      }
+    });
+  }
+
+  if (cliOption.sourcemap) {
+    left = mergeConfig(left, {
+      compilation: { sourcemap: cliOption.sourcemap }
+    });
+  }
+
+  return mergeConfig(left, target);
+}

packages/cli/src/plugin/index.ts

@@ -37,8 +37,9 @@ import { lazyCompilation } from './server/middlewares/lazy-compilation.js';
 import { resolveHostname } from './utils/http.js';
 
 export async function start(
-  inlineConfig: FarmCLIOptions & UserConfig
+  inlineConfig?: FarmCLIOptions & UserConfig
 ): Promise<void> {
+  inlineConfig = inlineConfig ?? {};
   const logger = inlineConfig.logger ?? new Logger();
   setProcessEnv('development');
 
@@ -76,15 +77,17 @@ export async function start(
 }
 
 export async function build(
-  inlineConfig: FarmCLIOptions & UserConfig
+  inlineConfig?: FarmCLIOptions & UserConfig
 ): Promise<void> {
+  inlineConfig = inlineConfig ?? {};
   const logger = inlineConfig.logger ?? new Logger();
   setProcessEnv('production');
 
   const resolvedUserConfig = await resolveConfig(
     inlineConfig,
     logger,
-    'production'
+    'production',
+    false
   );
 
   try {
@@ -96,7 +99,8 @@ export async function build(
   }
 }
 
-export async function preview(inlineConfig: FarmCLIOptions): Promise<void> {
+export async function preview(inlineConfig?: FarmCLIOptions): Promise<void> {
+  inlineConfig = inlineConfig ?? {};
   const logger = inlineConfig.logger ?? new Logger();
   const resolvedUserConfig = await resolveConfig(
     inlineConfig,
@@ -141,8 +145,9 @@ export async function preview(inlineConfig: FarmCLIOptions): Promise<void> {
 }
 
 export async function watch(
-  inlineConfig: FarmCLIOptions & UserConfig
+  inlineConfig?: FarmCLIOptions & UserConfig
 ): Promise<void> {
+  inlineConfig = inlineConfig ?? {};
   const logger = inlineConfig.logger ?? new Logger();
   setProcessEnv('development');
 
@@ -206,7 +211,7 @@ export async function watch(
 
 export async function clean(
   rootPath: string,
-  recursive: boolean | undefined
+  recursive?: boolean | undefined
 ): Promise<void> {
   // TODO After optimizing the reading of config, put the clean method into compiler
   const logger = new Logger();

packages/cli/src/plugin/prepublish.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'vitest';
+import { mergeFarmCliConfig } from '../../src/config/mergeConfig.js';
+import path from 'path';
+
+describe('mergeFarmCliConfig', () => {
+  test('inlineOption.root not empty', () => {
+    const result = mergeFarmCliConfig({}, { root: '/path/to/' });
+
+    expect(result).toEqual({ root: '/path/to/' });
+  });
+
+  test('userConfig.root not empty', () => {
+    const result = mergeFarmCliConfig({ root: '/path/to/' }, {});
+
+    expect(result).toEqual({ root: '/path/to/' });
+  });
+
+  test('userConfig.root both inlineOption not empty', () => {
+    const result = mergeFarmCliConfig(
+      { root: '/path/to/inlineOption' },
+      { root: '/path/to/userConfig' }
+    );
+
+    expect(result).toEqual({ root: '/path/to/userConfig' });
+  });
+
+  test('userConfig.root relative, should have configPath', () => {
+    expect(() => {
+      mergeFarmCliConfig({ root: './path/to/' }, { root: './path/userConfig' });
+    }).toThrow();
+
+    const result = mergeFarmCliConfig(
+      { root: './path/to/', configPath: process.cwd() },
+      { root: './path/userConfig' }
+    );
+
+    expect(result).toEqual({
+      root: path.resolve(process.cwd(), './path/userConfig')
+    });
+  });
+});

packages/cli/templates/js-plugin/farm.config.mjs

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { mergeConfig } from '../../src/config/mergeConfig.js';
+import { UserConfig } from '../../src/index.js';
+
+describe('mergeConfig', () => {
+  test('merge object', () => {
+    const fileConfig: UserConfig = {
+      compilation: {
+        input: {
+          index: 'src/index.ts'
+        }
+      }
+    };
+
+    const inputConfig: UserConfig = {
+      compilation: {
+        input: {
+          index2: 'src/index.ts'
+        }
+      }
+    };
+    const result: UserConfig = mergeConfig(fileConfig, inputConfig);
+
+    expect(result).toEqual({
+      compilation: {
+        input: {
+          index: 'src/index.ts',
+          index2: 'src/index.ts'
+        }
+      }
+    });
+  });
+
+  test('merge arr', () => {
+    const fileConfig: UserConfig = {
+      plugins: ['a']
+    };
+
+    const inputConfig: UserConfig = {
+      plugins: ['b'],
+      vitePlugins: [{ name: 'test' }]
+    };
+    const result: UserConfig = mergeConfig(fileConfig, inputConfig);
+
+    expect(result).toEqual({
+      plugins: ['a', 'b'],
+      vitePlugins: [{ name: 'test' }]
+    });
+  });
+
+  test('merge right to left', () => {
+    const fileConfig: UserConfig = {};
+
+    const inputConfig: UserConfig = {
+      plugins: ['b']
+    };
+    const result: UserConfig = mergeConfig(fileConfig, inputConfig);
+
+    expect(result).toEqual({
+      plugins: ['b']
+    });
+  });
+});