@tramvai/cli 2.64.0 → 2.66.0

package/src/config/configManager.spec.ts

@@ -0,0 +1,49 @@
+import type { ConfigEntry } from '../typings/configEntry/common';
+import { createConfigManager } from './configManager';
+
+jest.mock('./validate', () => {
+  const original = jest.requireActual('./validate');
+
+  return { ...original, validate: () => true };
+});
+
+const configEntry: ConfigEntry & Record<string, any> = {
+  name: 'test',
+  root: 'src',
+  type: 'package',
+  optionBoolean: false,
+  optionString: 'str',
+  optionOverride: {
+    development: '123',
+    production: '456',
+  },
+} as const;
+
+it('should pass configEntry options', () => {
+  const configManager = createConfigManager(configEntry, {});
+
+  expect(configManager.optionBoolean).toBe(false);
+  expect(configManager.optionString).toBe('str');
+});
+
+describe('should resolve settings depending on env', () => {
+  it('development', () => {
+    const configManager = createConfigManager(configEntry, { env: 'development' });
+
+    expect(configManager.optionOverride).toEqual('123');
+  });
+
+  it('production', () => {
+    const configManager = createConfigManager(configEntry, { env: 'production' });
+
+    expect(configManager.optionOverride).toBe('456');
+  });
+});
+
+it('hydration', () => {
+  const configManager = createConfigManager(configEntry, {});
+
+  const rehydrated = createConfigManager(...configManager.dehydrate());
+
+  expect(JSON.stringify(rehydrated)).toEqual(JSON.stringify(configManager));
+});

package/src/config/configManager.ts

@@ -1,16 +1,20 @@
 import isNil from '@tinkoff/utils/is/nil';
+import isArray from '@tinkoff/utils/is/array';
+import isObject from '@tinkoff/utils/is/object';
 import prop from '@tinkoff/utils/object/prop';
+import mapObj from '@tinkoff/utils/object/map';
 import { resolve } from 'path';
-import type { ProjectType, BuildType } from '../typings/projectType';
+import type { BuildType } from '../typings/projectType';
 import type { Env } from '../typings/Env';
-import type { ConfigEntry } from '../typings/configEntry/common';
-import { validate } from './validate';
+import type { ConfigEntry, OverridableOption } from '../typings/configEntry/common';
+import { isOverridableOption } from '../typings/configEntry/common';
+import { isApplication, isChildApp, isModule, validate } from './validate';
 import moduleVersion from '../utils/moduleVersion';
 import { packageVersion } from '../utils/packageVersion';
-import type { DeduplicateStrategy } from '../library/webpack/plugins/DedupePlugin';
 import { showConfig } from './showConfig';
 import type { Target } from '../typings/target';
 
+// @TODO: maybe split settings depending on env?
 export interface Settings<E extends Env> {
   env?: E;
   rootDir?: string;
@@ -18,7 +22,6 @@ export interface Settings<E extends Env> {
   buildType?: BuildType;
   debug?: boolean;
   trace?: boolean;
-  removeTypeofWindow?: boolean;
   sourceMap?: boolean;
   host?: string;
   port?: number;
@@ -37,7 +40,7 @@ export interface Settings<E extends Env> {
   csr?: boolean;
 }
 
-const getOption = <T>(optionName: string, cfgs: any[], dflt?: T): T => {
+const getOption = <T>(optionName: string, cfgs: any[], dflt: T): T => {
   const getter = prop(optionName);
 
   for (let i = 0; i < cfgs.length; i++) {
@@ -51,207 +54,136 @@ const getOption = <T>(optionName: string, cfgs: any[], dflt?: T): T => {
   return dflt;
 };
 
-export class ConfigManager<T extends ConfigEntry = ConfigEntry, E extends Env = any>
-  implements Required<Settings<E>>
-{
-  private configEntry: T;
-
-  public name: string;
-
-  public type: ProjectType;
-
-  public root: string;
-
-  public build: T['commands']['build'];
-
-  public serve: T['commands']['serve'];
-
-  private settings: Settings<E>;
-
-  public version: string;
-
-  public env: E;
-
-  public buildType: BuildType;
-
-  public rootDir: string;
-
-  public debug: boolean;
-
-  public trace: boolean;
-
-  public sourceMap: boolean;
-
-  public host: string;
-
-  public port: number;
-
-  public staticHost: string;
-
-  public staticPort: number;
-
-  public profile: boolean;
-
-  public noServerRebuild: boolean;
-
-  public noClientRebuild: boolean;
-
-  public modern: boolean;
-
-  public dedupe: DeduplicateStrategy | false;
-
-  public dedupeIgnore?: RegExp[];
-
-  public removeTypeofWindow: boolean;
-
-  public resolveSymlinks: boolean;
-
-  public hotRefresh: boolean;
-
-  public disableProdOptimization: boolean;
-
-  public target: Target;
-
-  public fileCache: boolean;
-
-  public experiments: T['commands'][E extends 'development'
-    ? 'serve'
-    : 'build']['configurations']['experiments'];
-
-  public showConfig: boolean;
-
-  public csr: boolean;
-
-  // eslint-disable-next-line complexity,max-statements
-  constructor(configEntry: T, settings: Settings<E>) {
-    this.configEntry = configEntry;
-    this.name = configEntry.name;
-    this.type = configEntry.type;
-    this.root = configEntry.root;
-    this.build = configEntry.commands.build || {};
-    this.serve = configEntry.commands.serve || {};
-
-    this.settings = settings;
-    this.env = settings.env || ('development' as E);
-    this.rootDir = settings.rootDir || process.cwd();
-    this.version =
-      settings.version ||
-      (this.type === 'module' ? moduleVersion(configEntry) : '') ||
-      (this.type === 'child-app' ? packageVersion(configEntry, this.env, this.rootDir) : '');
-    this.buildType = settings.buildType || 'client';
-    this.debug = settings.debug || false;
-    this.trace = settings.trace || false;
-    this.sourceMap =
-      this.buildType === 'server' && this.debug
-        ? true
-        : getOption(
-            'sourceMap',
-            [
-              settings,
-              this.env === 'development' ? this.serve.configurations : this.build.configurations,
-            ],
-            false
-          );
-    this.host = settings.host || '0.0.0.0';
-    this.port = Number(settings.port ?? 3000);
-    this.staticHost = settings.staticHost || 'localhost';
-    this.staticPort = Number(settings.staticPort ?? (this.type === 'module' ? 4040 : 4000));
-    this.profile = settings.profile || false;
-    this.noServerRebuild = settings.noServerRebuild || false;
-    this.noClientRebuild = settings.noClientRebuild || false;
-    this.modern = getOption(
-      'modern',
-      [
-        settings,
-        this.env === 'development' ? this.serve.configurations : this.build.configurations,
-      ],
-      true
-    );
-    this.dedupe = this.build.configurations?.dedupe;
-    this.dedupeIgnore = this.build.configurations?.dedupeIgnore?.map(
-      (ignore) => new RegExp(`^${ignore}`)
-    );
-    this.removeTypeofWindow = this.build.configurations?.removeTypeofWindow;
-    this.resolveSymlinks = settings.resolveSymlinks ?? true;
-    this.hotRefresh = this.env === 'development' && this.serve.configurations?.hotRefresh;
-    this.disableProdOptimization = settings.disableProdOptimization ?? false;
-    this.onlyBundles = settings.onlyBundles;
-    this.target = this.resolveTarget();
-    // according to measures fileCache in webpack doesn't affect
-    // performance much so enable it by default as it always was before
-    this.fileCache = settings.fileCache ?? true;
-    this.experiments =
-      (this.env === 'development'
-        ? this.serve.configurations?.experiments
-        : this.build.configurations?.experiments) ?? {};
-    this.showConfig = settings.showConfig ?? false;
-    this.csr = settings.csr ?? false;
+type OmitOverridable<T extends Record<string, any>> = {
+  [key in keyof T]: T[key] extends OverridableOption<infer U>
+    ? U
+    : T[key] extends Record<string, any>
+    ? OmitOverridable<T[key]>
+    : T[key];
+};
 
-    if (this.showConfig) {
-      showConfig(this);
+const omitEnvOptions = <T extends Record<string, any>>(
+  env: Env,
+  options: T
+): OmitOverridable<T> => {
+  return mapObj((value) => {
+    if (isOverridableOption(value)) {
+      return value[env];
     }
 
-    validate(this);
-  }
-
-  public onlyBundles: string[];
-
-  getBuildPath() {
-    switch (this.type) {
-      case 'application':
-        return resolve(
-          this.rootDir,
-          this.buildType === 'server'
-            ? this.build.options.outputServer
-            : this.build.options.outputClient
-        );
-      case 'module':
-        return resolve(
-          this.rootDir,
-          ...this.build.options.output.split('/'),
-          this.name,
-          this.version
-        );
-      case 'child-app':
-        return resolve(this.rootDir, ...this.build.options.output.split('/'));
+    if (isObject(value) && !isArray(value)) {
+      return omitEnvOptions(env, value);
     }
 
-    throw new Error('projectType not supported');
-  }
+    return value;
+  }, options);
+};
 
-  withSettings(settings: Settings<E>) {
-    return new ConfigManager(this.configEntry, {
-      ...this.settings,
-      ...settings,
-    });
+export type ConfigManager<
+  C extends ConfigEntry = ConfigEntry,
+  E extends Env = Env
+> = OmitOverridable<C> &
+  Required<Settings<E>> & {
+    target: Target;
+    buildPath: string;
+    withSettings(settings: Settings<E>): ConfigManager<C, E>;
+    dehydrate(): [C, Settings<E>];
+  };
+
+export const DEFAULT_PORT = 3000;
+export const DEFAULT_STATIC_PORT = 4000;
+export const DEFAULT_STATIC_MODULE_PORT = 4040;
+
+export const createConfigManager = <C extends ConfigEntry = ConfigEntry, E extends Env = Env>(
+  configEntry: C,
+  settings: Settings<E>
+): ConfigManager<C, E> => {
+  const env: E = settings.env ?? ('development' as E);
+  const normalizedConfigEntry = omitEnvOptions(env, configEntry);
+
+  const { type } = configEntry;
+  const rootDir = settings.rootDir ?? process.cwd();
+  const debug = settings.debug ?? false;
+  const modern = getOption('modern', [settings, configEntry], true);
+  const buildType = settings.buildType ?? 'client';
+  let target: Target = 'defaults';
+
+  if (buildType === 'server') {
+    target = 'node';
+  } else if (modern) {
+    target = 'modern';
   }
 
-  dehydrate() {
-    return {
-      configEntry: this.configEntry,
-      settings: {
-        ...this.settings,
-        rootDir: this.rootDir,
-        // drop options that couldn't be serialized
-        stdout: undefined,
-        stderr: undefined,
-      },
-    };
+  const config: ConfigManager<C, E> = {
+    ...normalizedConfigEntry,
+    version:
+      (type === 'module' ? moduleVersion(configEntry) : '') ||
+      (type === 'child-app' ? packageVersion(configEntry, env, rootDir) : ''),
+    trace: false,
+    host: '0.0.0.0',
+    staticHost: 'localhost',
+    profile: false,
+    noClientRebuild: false,
+    noServerRebuild: false,
+    resolveSymlinks: true,
+    disableProdOptimization: false,
+    onlyBundles: [],
+    // according to measures fileCache in webpack doesn't affect
+    // performance much so enable it by default as it always was before
+    fileCache: true,
+    showConfig: false,
+    csr: false,
+    ...settings,
+    env,
+    rootDir,
+    buildType,
+    debug,
+    port: Number(settings.port ?? DEFAULT_PORT),
+    staticPort: Number(
+      settings.staticPort ?? (type === 'module' ? DEFAULT_STATIC_MODULE_PORT : DEFAULT_STATIC_PORT)
+    ),
+    modern,
+    sourceMap:
+      buildType === 'server' && debug
+        ? true
+        : getOption('sourceMap', [settings, normalizedConfigEntry], false),
+    target,
+    buildPath: '',
+    withSettings(overrideSettings) {
+      return createConfigManager(configEntry, {
+        ...settings,
+        ...overrideSettings,
+      });
+    },
+    dehydrate() {
+      return [
+        configEntry,
+        {
+          ...settings,
+          // drop options that couldn't be serialized
+          stdout: undefined,
+          stderr: undefined,
+        },
+      ];
+    },
+  };
+
+  if (isApplication(config)) {
+    config.buildPath = resolve(
+      rootDir,
+      buildType === 'server' ? config.output.server : config.output.client
+    );
+  } else if (isChildApp(config)) {
+    config.buildPath = resolve(rootDir, ...config.output.split('/'));
+  } else if (isModule(config)) {
+    config.buildPath = resolve(rootDir, ...config.output.split('/'), config.name, config.version);
   }
 
-  static rehydrate(state: ReturnType<ConfigManager['dehydrate']>) {
-    return new ConfigManager(state.configEntry, state.settings);
+  if (config.showConfig) {
+    showConfig(config);
   }
 
-  private resolveTarget(): Target {
-    if (this.buildType === 'server') {
-      return 'node';
-    }
-
-    if (this.modern) {
-      return 'modern';
-    }
+  validate(config);
 
-    return 'defaults';
-  }
-}
+  return config;
+};

package/src/config/showConfig.ts

@@ -4,8 +4,8 @@ import chalk from 'chalk';
 import type { ConfigManager } from './configManager';
 import { box } from '../utils/formatting';
 
-export const showConfig = (configManager: ConfigManager) => {
-  const configStr = prettyoutput(omit(['configEntry'], configManager), {
+export const showConfig = (configManager: ConfigManager<any, any>) => {
+  const configStr = prettyoutput(omit(['options'], configManager), {
     hideUndefined: true,
     maxDepth: Infinity,
   });

package/src/config/validate.ts

@@ -3,24 +3,25 @@ import { sync as requireResolve } from 'resolve';
 import type { ConfigManager } from './configManager';
 import type { ApplicationConfigEntry } from '../typings/configEntry/application';
 import type { ModuleConfigEntry } from '../typings/configEntry/module';
-import { extensions } from './constants';
 import type { ChildAppConfigEntry } from '../typings/configEntry/child-app';
+import { extensions } from './constants';
+import type { Env } from '../typings/Env';
 
-export const isApplication = (
-  configManager: ConfigManager
-): configManager is ConfigManager<ApplicationConfigEntry> => {
+export const isApplication = <E extends Env>(
+  configManager: ConfigManager<any, E>
+): configManager is ConfigManager<ApplicationConfigEntry, E> => {
   return configManager.type === 'application';
 };
 
-export const isModule = (
-  configManager: ConfigManager
-): configManager is ConfigManager<ModuleConfigEntry> => {
+export const isModule = <E extends Env>(
+  configManager: ConfigManager<any, E>
+): configManager is ConfigManager<ModuleConfigEntry, E> => {
   return configManager.type === 'module';
 };
 
-export const isChildApp = (
-  configManager: ConfigManager
-): configManager is ConfigManager<ChildAppConfigEntry> => {
+export const isChildApp = <E extends Env>(
+  configManager: ConfigManager<any, E>
+): configManager is ConfigManager<ChildAppConfigEntry, E> => {
   return configManager.type === 'child-app';
 };
 
@@ -28,7 +29,7 @@ const throwErrorMissing = (config: string, path: string) => {
   throw new Error(`Can not resolve '${path}', check your configuration: '${config}'`);
 };
 
-export const validate = (configManager: ConfigManager) => {
+export const validate = (configManager: ConfigManager<any, any>) => {
   const { rootDir } = configManager;
 
   const isMissing = (path: string) => {
@@ -43,27 +44,15 @@ export const validate = (configManager: ConfigManager) => {
   };
 
   if (isApplication(configManager)) {
-    const {
-      root,
-      buildType,
-      build: { options },
-    } = configManager;
+    const { root, buildType, polyfill } = configManager;
 
     if (buildType === 'client') {
-      const { polyfill } = options;
-
       if (isMissing(root)) {
         throwErrorMissing('root', `${root}/index`);
       }
 
       if (polyfill && isMissing(polyfill)) {
-        throwErrorMissing('commands.build.options.polyfill', polyfill);
-      }
-    } else {
-      const { server } = options;
-
-      if (isMissing(server)) {
-        throwErrorMissing('commands.build.options.server', server);
+        throwErrorMissing('polyfill', polyfill);
       }
     }
   } else if (isModule(configManager)) {

package/src/di/tokens/config.ts

@@ -2,10 +2,11 @@ import { createToken } from '@tinkoff/dippy';
 import type { ConfigEntry } from '../../typings/configEntry/common';
 import type { ConfigManager } from '../../config/configManager';
 import type { Env } from '../../typings/Env';
+import type { CliConfigEntry } from '../../typings/configEntry/cli';
 
 export const CLI_ROOT_DIR_TOKEN = createToken<string>('cli rootDir');
 export const CONFIG_ROOT_DIR_TOKEN = createToken<string>('config rootDir');
 
 export const CONFIG_ENV_TOKEN = createToken<Env>('config env');
 export const CONFIG_ENTRY_TOKEN = createToken<ConfigEntry>('config entry');
-export const CONFIG_MANAGER_TOKEN = createToken<ConfigManager>('config manager');
+export const CONFIG_MANAGER_TOKEN = createToken<ConfigManager<CliConfigEntry>>('config manager');

package/src/library/babel/index.ts

@@ -144,6 +144,7 @@ export const babelConfigFactory = ({
       ],
       tramvai && env === 'development' && path.resolve(__dirname, './plugins/provider-stack'),
       !isServer &&
+        env === 'development' &&
         hot && ['react-refresh/babel', { skipEnvCheck: process.env.NODE_ENV === 'test' }],
     ]
       .concat(cfg.plugins || [])

package/src/library/swc/__integration__/swc.build.test.ts

@@ -26,27 +26,9 @@ beforeAll(async () => {
       name: 'swc-app',
       type: 'application',
       root: './',
-      commands: {
-        build: {
-          options: {
-            server: 'index.ts',
-          },
-          configurations: {
-            experiments: {
-              transpilation: {
-                loader: 'swc',
-              },
-            },
-          },
-        },
-        serve: {
-          configurations: {
-            experiments: {
-              transpilation: {
-                loader: 'swc',
-              },
-            },
-          },
+      experiments: {
+        transpilation: {
+          loader: 'swc',
         },
       },
     },

package/src/library/swc/__integration__/swc.start.test.ts

@@ -37,27 +37,9 @@ beforeAll(async () => {
       name: 'swc-app',
       type: 'application',
       root: './',
-      commands: {
-        build: {
-          options: {
-            server: 'index.ts',
-          },
-          configurations: {
-            experiments: {
-              transpilation: {
-                loader: 'swc',
-              },
-            },
-          },
-        },
-        serve: {
-          configurations: {
-            experiments: {
-              transpilation: {
-                loader: 'swc',
-              },
-            },
-          },
+      experiments: {
+        transpilation: {
+          loader: 'swc',
         },
       },
     },

package/src/library/swc/index.ts

@@ -123,7 +123,7 @@ Having swc config may conflict with @tramvai/cli configuration`
         react: {
           runtime: hasJsxRuntime() ? 'automatic' : 'classic',
           development: env === 'development',
-          refresh: hot && !isServer,
+          refresh: hot && env === 'development' && !isServer,
         },
         optimizer: {
           globals: {

package/src/library/webpack/application/client/common.ts

@@ -18,12 +18,10 @@ import nodeClient from '../../blocks/nodeClient';
 import { pagesResolve } from '../../blocks/pagesResolve';
 import { DEFAULT_STATS_OPTIONS, DEFAULT_STATS_FIELDS } from '../../constants/stats';
 import { configToEnv } from '../../blocks/configToEnv';
+import { safeRequireResolve } from '../../../../utils/safeRequire';
 
 export default (configManager: ConfigManager<ApplicationConfigEntry>) => (config: Config) => {
-  const {
-    options: { polyfill = '' } = {},
-    configurations: { fileSystemPages },
-  } = configManager.build;
+  const { polyfill, fileSystemPages } = configManager;
 
   config.name('client');
 
@@ -31,7 +29,7 @@ export default (configManager: ConfigManager<ApplicationConfigEntry>) => (config
   config.batch(commonApplication(configManager));
   config.batch(files(configManager));
 
-  if (fileSystemPages.enable) {
+  if (fileSystemPages.enabled) {
     config.batch(pagesResolve(configManager));
   }
 
@@ -56,8 +54,10 @@ export default (configManager: ConfigManager<ApplicationConfigEntry>) => (config
     ])
     .end();
 
-  if (polyfill) {
-    config.entry('polyfill').add(path.resolve(configManager.rootDir, polyfill));
+  const polyfillPath = path.resolve(configManager.rootDir, polyfill ?? 'src/polyfill');
+
+  if (safeRequireResolve(polyfillPath, typeof polyfill === 'undefined')) {
+    config.entry('polyfill').add(polyfillPath);
   }
 
   const statsFileName = configManager.modern ? 'stats.modern.json' : 'stats.json';