@tramvai/cli 5.53.80 → 6.62.0

package/src/api/start/application.experimental.ts

@@ -0,0 +1,305 @@
+import path from 'node:path';
+import type { Container } from '@tinkoff/dippy';
+import { StartParameters, start } from '@tramvai/api/lib/api/start';
+import { ApplicationProject, Configuration } from '@tramvai/api/lib/config';
+import {
+  COMMAND_PARAMETERS_TOKEN,
+  CONFIG_ENTRY_TOKEN,
+  CONFIG_ROOT_DIR_TOKEN,
+} from '../../di/tokens';
+import { getTramvaiConfig } from '../../utils/getTramvaiConfig';
+import { ApplicationConfigEntry } from '../../typings/configEntry/application';
+import type { Params, Result } from './index';
+
+declare global {
+  // eslint-disable-next-line no-var, vars-on-top
+  var __TRAMVAI_EXIT_HANDLERS__: Array<() => Promise<any>>;
+}
+
+export const startApplicationExperimental = async (di: Container): Result => {
+  const configEntry = di.get(CONFIG_ENTRY_TOKEN);
+  const options = di.get(COMMAND_PARAMETERS_TOKEN as Params);
+  const rootDir = di.get(CONFIG_ROOT_DIR_TOKEN);
+
+  const inputParameters: StartParameters = {
+    name: configEntry.name,
+    mode: 'development',
+    buildType: options.buildType,
+    port: options.port,
+    host: options.host,
+    staticPort: options.staticPort,
+    staticHost: options.staticHost,
+    noServerRebuild: options.noServerRebuild,
+    noClientRebuild: options.noClientRebuild,
+    resolveSymlinks: options.resolveSymlinks,
+    fileCache: options.fileCache,
+    showProgress: true,
+    verboseLogging: options.verboseWebpack,
+  };
+
+  const { content, projects } = mapTramvaiJsonToNewTsConfig({ rootDir });
+
+  const hasSwcTranspiler = Object.values(content.projects).some((project) => {
+    if (
+      project.type !== 'application' ||
+      !(project as ApplicationConfigEntry).experiments?.transpilation
+    ) {
+      return false;
+    }
+    const { loader } = (project as ApplicationConfigEntry).experiments.transpilation;
+
+    if (typeof loader === 'string') {
+      // @ts-expect-error
+      return loader === 'swc';
+    }
+    // @ts-expect-error
+    return loader.development === 'swc';
+  });
+  const hasPwa = Object.values(content.projects).some((project) => {
+    if (project.type !== 'application' || !(project as ApplicationConfigEntry).experiments) {
+      return false;
+    }
+    const { pwa } = (project as ApplicationConfigEntry).experiments;
+    return !!pwa;
+  });
+
+  const extraConfiguration: Partial<Configuration> = {
+    projects,
+    plugins: [
+      '@tramvai/plugin-webpack-builder',
+      hasSwcTranspiler ? '@tramvai/plugin-swc-transpiler' : '@tramvai/plugin-babel-transpiler',
+      hasPwa && '@tramvai/plugin-webpack-pwa',
+    ].filter(Boolean),
+  };
+
+  const devServer = await start(inputParameters, extraConfiguration);
+
+  // CLI will wait for this handlers before exiting
+  // @reference `packages/cli/src/cli/runCLI.ts`
+  if (!global.__TRAMVAI_EXIT_HANDLERS__) {
+    global.__TRAMVAI_EXIT_HANDLERS__ = [];
+  }
+
+  global.__TRAMVAI_EXIT_HANDLERS__.push(async () => {
+    await devServer?.close?.();
+  });
+
+  try {
+    await devServer.buildPromise;
+  } catch (e) {
+    // some webpack build errors can be safely ignored
+    // TODO: strictErrorHandle parameter? used in `packages/cli/src/library/swc/__integration__/swc.start.test.ts` for old cli
+  }
+
+  return {
+    server: devServer.httpServer,
+    staticServer: devServer.staticHttpServer,
+    close: async () => {
+      await devServer.close();
+    },
+    invalidate: async () => {
+      await devServer.invalidate();
+    },
+    getBuildStats: () => {
+      return {};
+    },
+    builder: {
+      name: '@tramvai/plugin-webpack-builder',
+      start: async (options) => {
+        return {
+          close: async () => {
+            await devServer.close();
+          },
+          invalidate: async () => {
+            await devServer.invalidate();
+          },
+          getBuildStats: () => {
+            return {};
+          },
+        };
+      },
+      build: async (options) => {
+        return {
+          getBuildStats: () => {
+            return {};
+          },
+        };
+      },
+      analyze: async (options) => {},
+      on: (event, callback) => {
+        // TODO useful events as public new devServer API
+      },
+    },
+  };
+};
+
+/**
+ * Mapping from tramvai.json config format to new tramvai.config.ts,
+ * for seamless migration
+ */
+// eslint-disable-next-line max-statements, complexity
+function mapTramvaiJsonToNewTsConfig({ rootDir }: { rootDir: string }) {
+  const { content } = getTramvaiConfig(rootDir);
+  const projects: Configuration['projects'] = {};
+
+  for (const projectName in content.projects) {
+    const project = content.projects[projectName];
+
+    if (project.type === 'application') {
+      const applicationProject = project as ApplicationConfigEntry;
+
+      const mappedProject: ApplicationProject = {
+        name: projectName,
+        type: 'application',
+        deprecatedLessSupport: true,
+      };
+
+      if (applicationProject.root) {
+        mappedProject.sourceDir = applicationProject.root;
+      }
+      if (applicationProject.output) {
+        mappedProject.output = {};
+
+        if (applicationProject.output.server) {
+          mappedProject.output.server = applicationProject.output.server;
+        }
+        if (applicationProject.output.client) {
+          mappedProject.output.client = applicationProject.output.client;
+        }
+        if (applicationProject.output.static) {
+          mappedProject.output.static = applicationProject.output.static;
+        }
+      }
+      if (applicationProject.fileSystemPages) {
+        mappedProject.fileSystemPages = applicationProject.fileSystemPages;
+      }
+      if (applicationProject.experiments && 'runtimeChunk' in applicationProject.experiments) {
+        mappedProject.runtimeChunk = applicationProject.experiments.runtimeChunk;
+      }
+      if (applicationProject.experiments && 'viewTransitions' in applicationProject.experiments) {
+        mappedProject.experiments.viewTransitions = applicationProject.experiments.viewTransitions;
+      }
+      if (applicationProject.experiments && 'reactTransitions' in applicationProject.experiments) {
+        mappedProject.experiments.reactTransitions =
+          applicationProject.experiments.reactTransitions;
+      }
+      if (
+        applicationProject.experiments &&
+        'enableFillDeclareActionNamePlugin' in applicationProject.experiments
+      ) {
+        mappedProject.enableFillDeclareActionNamePlugin =
+          applicationProject.experiments.enableFillDeclareActionNamePlugin;
+      }
+      if (applicationProject.serverApiDir) {
+        mappedProject.fileSystemPapiDir = path.resolve(applicationProject.serverApiDir);
+      }
+      if (applicationProject.postcss) {
+        mappedProject.postcss = applicationProject.postcss;
+
+        if (mappedProject.postcss.config) {
+          // TODO file outside src dir
+          if (mappedProject.postcss.config.startsWith(applicationProject.root)) {
+            mappedProject.postcss.config = mappedProject.postcss.config.replace(
+              `${applicationProject.root}/`,
+              ''
+            );
+          } else if (mappedProject.postcss.config.startsWith('./')) {
+            mappedProject.postcss.config = path.resolve(mappedProject.postcss.config);
+          }
+        }
+      }
+      if (applicationProject.polyfill) {
+        try {
+          if (require.resolve(mappedProject.polyfill).includes('node_modules')) {
+            mappedProject.polyfill = require.resolve(applicationProject.polyfill);
+          } else {
+            mappedProject.polyfill = path.resolve(applicationProject.polyfill);
+          }
+        } catch (e) {
+          mappedProject.polyfill = path.resolve(applicationProject.polyfill);
+        }
+      }
+      if (applicationProject.modernPolyfill) {
+        try {
+          if (require.resolve(mappedProject.modernPolyfill).includes('node_modules')) {
+            mappedProject.polyfill = require.resolve(applicationProject.modernPolyfill);
+          } else {
+            mappedProject.polyfill = path.resolve(applicationProject.modernPolyfill);
+          }
+        } catch (e) {
+          mappedProject.polyfill = path.resolve(applicationProject.modernPolyfill);
+        }
+      }
+      if (applicationProject.dedupe) {
+        mappedProject.dedupe = applicationProject.dedupe;
+      }
+      if ('integrity' in applicationProject) {
+        if (typeof applicationProject.integrity === 'boolean') {
+          mappedProject.integrity = {
+            enabled: applicationProject.integrity,
+          };
+        } else {
+          // @ts-expect-error inconsistent `hashFuncNames` types
+          mappedProject.integrity = applicationProject.integrity;
+        }
+      }
+      if (
+        applicationProject.splitChunks &&
+        (applicationProject.splitChunks.mode === 'granularChunks' ||
+          applicationProject.splitChunks.mode === false)
+      ) {
+        // @ts-expect-error `commonChunk` is not supported in new cli
+        mappedProject.splitChunks = applicationProject.splitChunks;
+      }
+      if (applicationProject.webpack?.resolveAlias) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.resolveAlias = applicationProject.webpack.resolveAlias;
+      }
+      if (applicationProject.webpack?.provide) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.provide = applicationProject.webpack.provide;
+      }
+      if (applicationProject.webpack?.watchOptions) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.watchOptions = applicationProject.webpack.watchOptions;
+      }
+      if (applicationProject.webpack && 'devtool' in applicationProject.webpack) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.devtool = applicationProject.webpack.devtool;
+      }
+      if (applicationProject.experiments?.pwa) {
+        mappedProject.pwa = {
+          workbox: {
+            ...applicationProject.experiments.pwa.workbox,
+            enabled:
+              typeof applicationProject.experiments.pwa.workbox.enabled === 'boolean'
+                ? applicationProject.experiments.pwa.workbox.enabled
+                : applicationProject.experiments.pwa.workbox.enabled.development,
+          },
+          sw: applicationProject.experiments.pwa.sw,
+          webmanifest: applicationProject.experiments.pwa.webmanifest,
+          icon: applicationProject.experiments.pwa.icon,
+          meta: applicationProject.experiments.pwa.meta,
+        };
+      }
+      if (applicationProject.externals) {
+        if (!mappedProject.webpack) {
+          mappedProject.webpack = {};
+        }
+        mappedProject.webpack.externals = applicationProject.externals;
+      }
+
+      projects[projectName] = mappedProject;
+    }
+  }
+
+  return { content, projects };
+}

package/src/api/start/index.ts

@@ -3,10 +3,7 @@ import type { PromiseType } from 'utility-types';
 import type { Provider } from '@tinkoff/dippy';
 import { createCommand } from '../../commands/createCommand';
 import type { WithConfig } from '../shared/types/withConfig';
-import { startApplication } from './application';
-import { startModule } from './module';
-import { CONFIG_ENTRY_TOKEN, PORT_MANAGER_TOKEN } from '../../di/tokens';
-import { startChildApp } from './child-app';
+import { COMMAND_PARAMETERS_TOKEN, CONFIG_ENTRY_TOKEN, PORT_MANAGER_TOKEN } from '../../di/tokens';
 import type { Builder } from '../../typings/build/Builder';
 
 export type Params = WithConfig<{
@@ -33,6 +30,7 @@ export type Params = WithConfig<{
   onlyBundles?: string[];
   strictErrorHandle?: boolean;
   fileCache?: boolean;
+  experimentalWebpackWorkerThreads?: boolean;
 }>;
 
 export type Result<T extends string = any> = Promise<
@@ -49,17 +47,35 @@ export type StartCommand = (params: Params, providers?: Provider[]) => Result;
 export default createCommand({
   name: 'start',
   command: async (di): Result => {
+    const options = di.get(COMMAND_PARAMETERS_TOKEN as Params);
     const configEntry = di.get(CONFIG_ENTRY_TOKEN);
     const portManager = di.get(PORT_MANAGER_TOKEN);
 
+    if (options.experimentalWebpackWorkerThreads) {
+      if (configEntry.type !== 'application') {
+        throw new Error(
+          '--experimentalWebpackWorkerThreads option is only available for application project'
+        );
+      }
+
+      const { startApplicationExperimental } = require('./application.experimental');
+      return startApplicationExperimental(di);
+    }
+
     await portManager.computeAvailablePorts();
 
     switch (configEntry.type) {
       case 'application':
+        // eslint-disable-next-line no-case-declarations
+        const { startApplication } = require('./application');
         return startApplication(di);
       case 'module':
+        // eslint-disable-next-line no-case-declarations
+        const { startModule } = require('./module');
         return startModule(di);
       case 'child-app':
+        // eslint-disable-next-line no-case-declarations
+        const { startChildApp } = require('./child-app');
         return startChildApp(di);
     }
   },

package/src/builder/webpack/devServer/setup.ts

@@ -84,6 +84,7 @@ export const createDevServer = ({
     if (configManager.hotRefresh.enabled) {
       app.use(
         getHotModulePrefix(configManager),
+        // @ts-ignore - https://github.com/DefinitelyTyped/DefinitelyTyped/pull/73338
         webpackHotMiddleware(compiler, { log: false, statsOptions: { cached: false } })
       );
     }

package/src/builder/webpack/providers/analyze/shared.ts

@@ -10,10 +10,6 @@ import {
 } from '../../../../di/tokens';
 import { toWebpackConfig } from '../../../../library/webpack/utils/toWebpackConfig';
 import { npmRequire, npmRequireList } from '../../../../utils/npmRequire';
-import { BundleAnalyzePlugin } from '../../analyzePlugins/bundle';
-import { StatoscopeAnalyzePlugin } from '../../analyzePlugins/statoscope';
-import { WhyBundledAnalyzePlugin } from '../../analyzePlugins/whyBundled';
-import { RsdoctorAnalyzePlugin } from '../../analyzePlugins/rsdoctor';
 import {
   CLIENT_CONFIG_MANAGER_TOKEN,
   INIT_HANDLER_TOKEN,
@@ -31,18 +27,18 @@ interface Type<T> extends Function {
   new (...args: any[]): T;
 }
 
-const pluginMap: Record<string, Type<AnalyzePlugin>> = {
-  bundle: BundleAnalyzePlugin,
-  whybundled: WhyBundledAnalyzePlugin,
-  statoscope: StatoscopeAnalyzePlugin,
-  rsdoctor: RsdoctorAnalyzePlugin,
+const pluginMap: Record<string, () => Type<AnalyzePlugin>> = {
+  bundle: () => require('../../analyzePlugins/bundle').BundleAnalyzePlugin,
+  whybundled: () => require('../../analyzePlugins/whyBundled').WhyBundledAnalyzePlugin,
+  statoscope: () => require('../../analyzePlugins/statoscope').StatoscopeAnalyzePlugin,
+  rsdoctor: () => require('../../analyzePlugins/rsdoctor').RsdoctorAnalyzePlugin,
 };
 
 export const analyzeSharedProviders: Provider[] = [
   provide({
     provide: WEBPACK_ANALYZE_PLUGIN_TOKEN,
     useFactory: ({ pluginName }) => {
-      const PluginClass = pluginMap[pluginName];
+      const PluginClass = pluginMap[pluginName]();
 
       if (!PluginClass) {
         throw new Error('Set correct plugin option');

package/src/builder/webpack/providers/client.ts

@@ -7,18 +7,21 @@ import { CLIENT_CONFIG_MANAGER_TOKEN, WEBPACK_CLIENT_CONFIG_TOKEN } from '../tok
 import { CONFIG_GENERATOR_STUB } from '../stubs/config';
 import type { ConfigGenerator } from '../types';
 
-const CONFIG_MAP: Record<Env, Record<ProjectType, ConfigGenerator>> = {
+const CONFIG_MAP: Record<Env, Record<ProjectType, () => ConfigGenerator>> = {
   development: {
-    application: require('../../../library/webpack/application/client/dev').webpackClientConfig,
-    module: require('../../../library/webpack/module/client/dev').webpackClientConfig,
-    'child-app': require('../../../library/webpack/child-app/client/dev').webpackClientConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/client/dev').webpackClientConfig,
+    module: () => require('../../../library/webpack/module/client/dev').webpackClientConfig,
+    'child-app': () => require('../../../library/webpack/child-app/client/dev').webpackClientConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
   production: {
-    application: require('../../../library/webpack/application/client/prod').webpackClientConfig,
-    module: require('../../../library/webpack/module/client/prod').webpackClientConfig,
-    'child-app': require('../../../library/webpack/child-app/client/prod').webpackClientConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/client/prod').webpackClientConfig,
+    module: () => require('../../../library/webpack/module/client/prod').webpackClientConfig,
+    'child-app': () =>
+      require('../../../library/webpack/child-app/client/prod').webpackClientConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
 };
 
@@ -26,7 +29,9 @@ export const clientProviders: Provider[] = [
   provide({
     provide: WEBPACK_CLIENT_CONFIG_TOKEN,
     useFactory: ({ configManager, showProgress }) => {
-      return CONFIG_MAP[configManager.env][configManager.type]({
+      const webpackConfigFactory = CONFIG_MAP[configManager.env][configManager.type]();
+
+      return webpackConfigFactory({
         configManager,
         showProgress,
       });

package/src/builder/webpack/providers/server.ts

@@ -7,18 +7,21 @@ import { SERVER_CONFIG_MANAGER_TOKEN, WEBPACK_SERVER_CONFIG_TOKEN } from '../tok
 import { CONFIG_GENERATOR_STUB } from '../stubs/config';
 import type { ConfigGenerator } from '../types';
 
-const CONFIG_MAP: Record<Env, Record<ProjectType, ConfigGenerator>> = {
+const CONFIG_MAP: Record<Env, Record<ProjectType, () => ConfigGenerator>> = {
   development: {
-    application: require('../../../library/webpack/application/server/dev').webpackServerConfig,
-    module: require('../../../library/webpack/module/server/dev').webpackServerConfig,
-    'child-app': require('../../../library/webpack/child-app/server/dev').webpackServerConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/server/dev').webpackServerConfig,
+    module: () => require('../../../library/webpack/module/server/dev').webpackServerConfig,
+    'child-app': () => require('../../../library/webpack/child-app/server/dev').webpackServerConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
   production: {
-    application: require('../../../library/webpack/application/server/prod').webpackServerConfig,
-    module: require('../../../library/webpack/module/server/prod').webpackServerConfig,
-    'child-app': require('../../../library/webpack/child-app/server/prod').webpackServerConfig,
-    package: CONFIG_GENERATOR_STUB,
+    application: () =>
+      require('../../../library/webpack/application/server/prod').webpackServerConfig,
+    module: () => require('../../../library/webpack/module/server/prod').webpackServerConfig,
+    'child-app': () =>
+      require('../../../library/webpack/child-app/server/prod').webpackServerConfig,
+    package: () => CONFIG_GENERATOR_STUB,
   },
 };
 
@@ -37,7 +40,9 @@ export const serverProviders: Provider[] = [
   provide({
     provide: WEBPACK_SERVER_CONFIG_TOKEN,
     useFactory: ({ configManager, showProgress }) => {
-      return CONFIG_MAP[configManager.env][configManager.type]({
+      const webpackConfigFactory = CONFIG_MAP[configManager.env][configManager.type]();
+
+      return webpackConfigFactory({
         configManager,
         showProgress,
       });

package/src/cli/CLI.ts

@@ -1,11 +1,11 @@
 import type { PackageManager } from '@tinkoff/package-manager-wrapper';
+import { AnalyticsService } from '@tramvai/api/lib/services/analytics';
 import { commander } from '../ui/commander';
 import { Context } from '../models/context';
 import type { Command, CommandMap, CommandResult } from '../models/command';
 import type { Logger } from '../models/logger';
 import type { Task, TaskMap } from '../models/task';
 import type { ConfigManager } from '../models/config';
-import { AnalyticsService } from '../models/analytics/analytics';
 
 export class CLI {
   context: Context;

package/src/cli/bin-init.ts

@@ -1,9 +1,7 @@
 import resolve from 'resolve';
 import { clearExecArgv } from '../utils/clearExecArgv';
-import { initSentry } from '../utils/sentry';
 
 clearExecArgv();
-initSentry();
 
 resolve(
   '@tramvai/cli/lib/cli',

package/src/cli/index.ts

@@ -1,9 +1,12 @@
 import path from 'path';
 import { resolvePackageManager, NpmPackageManager } from '@tinkoff/package-manager-wrapper';
+import {
+  AnalyticsService,
+  resolveDependenciesProperties,
+} from '@tramvai/api/lib/services/analytics';
 import { CLI } from './CLI';
 import { Logger } from '../models/logger';
 import { ConfigManager } from '../models/config';
-import { initSentry } from '../utils/sentry';
 
 import type { CommandMap } from '../models/command';
 
@@ -26,7 +29,6 @@ import type { TaskMap } from '../models/task';
 import { getRootFile } from '../utils/getRootFile';
 import { getTramvaiConfig } from '../utils/getTramvaiConfig';
 import { syncJsonFile } from '../utils/syncJsonFile';
-import { AnalyticsService, resolveDependenciesProperties } from '../models/analytics/analytics';
 
 async function loadCommands(): Promise<CommandMap> {
   return [
@@ -54,14 +56,8 @@ const defaultPackageInfo = { name: 'init app', version: '0.0.1' };
 export async function cliInitialized(cliArgs = process.argv) {
   const logger = new Logger();
   let analytics: AnalyticsService;
-  const sentry = initSentry();
 
   try {
-    const commandContext = {
-      command: cliArgs[2] || '',
-      argv: cliArgs,
-    };
-    sentry.setContext('command', commandContext);
     const commandsMap = await loadCommands();
     const tasksMap = await loadTasks();
 
@@ -126,10 +122,7 @@ export async function cliInitialized(cliArgs = process.argv) {
       message: e.message || e,
       payload: e.details || e.stack,
     });
-    sentry.captureException(e);
 
     throw e;
-  } finally {
-    await sentry.close();
   }
 }

package/src/cli/runCLI.ts

@@ -1,5 +1,4 @@
 import exit from 'exit';
-
 import { fixYarnSettingsOverride } from '../utils/fixYarnSettingsOverride';
 import { handleErrors } from '../utils/handleErrors';
 

package/src/commands/add/command.ts

@@ -1,5 +1,4 @@
 import { CLICommand } from '../../models/command';
-import { checkPackage } from './checkPackageValidator';
 import type { Params } from './add';
 
 class AddCommand extends CLICommand {
@@ -23,7 +22,9 @@ class AddCommand extends CLICommand {
 
   alias = '';
 
-  validators = [checkPackage];
+  validators() {
+    return [require('./checkPackageValidator').checkPackage];
+  }
 
   async action(parameters: Params) {
     // used require for lazy code execution

package/src/commands/analyze/command.ts

@@ -1,10 +1,4 @@
 import { CLICommand } from '../../models/command';
-import { checkApplication } from '../../validators/commands/checkBuild';
-import { checkConfigExists } from '../../validators/commands/checkConfigExists';
-import { checkPwaDependencies } from '../../validators/commands/checkPwaDependencies';
-import { runMigrationsAndCheckVersions } from '../../validators/commands/runMigrationsAndCheckVersions';
-import { checkSwcDependencies } from '../../validators/commands/checkSwcDependencies';
-import { checkReactCompilerDependencies } from '../../validators/commands/checkReactCompilerDependencies';
 
 export type Params = {
   target: string;
@@ -46,14 +40,18 @@ class AnalyzeCommand extends CLICommand<Params> {
 
   alias = 'a';
 
-  validators = [
-    checkConfigExists,
-    checkApplication,
-    runMigrationsAndCheckVersions,
-    checkPwaDependencies,
-    checkSwcDependencies,
-    checkReactCompilerDependencies,
-  ];
+  validators() {
+    return [
+      require('../../validators/commands/checkConfigExists').checkConfigExists,
+      require('../../validators/commands/checkBuild').checkApplication,
+      require('../../validators/commands/runMigrationsAndCheckVersions')
+        .runMigrationsAndCheckVersions,
+      require('../../validators/commands/checkPwaDependencies').checkPwaDependencies,
+      require('../../validators/commands/checkSwcDependencies').checkSwcDependencies,
+      require('../../validators/commands/checkReactCompilerDependencies')
+        .checkReactCompilerDependencies,
+    ];
+  }
 
   action(parameters: Params) {
     // used require for lazy code execution

package/src/commands/benchmark/command.ts

@@ -1,8 +1,4 @@
 import { CLICommand } from '../../models/command';
-import { checkApplication } from '../../validators/commands/checkBuild';
-import { checkConfigExists } from '../../validators/commands/checkConfigExists';
-import { checkDependencies } from '../../validators/commands/checkDependencies';
-import { runMigrationsAndCheckVersions } from '../../validators/commands/runMigrationsAndCheckVersions';
 import type { Params as StartParams } from '../start/command';
 
 export type Params = StartParams & {
@@ -45,12 +41,15 @@ export class BenchmarkCommand extends CLICommand<Params> {
 
   alias = 'bench';
 
-  validators = [
-    checkConfigExists,
-    checkApplication,
-    runMigrationsAndCheckVersions,
-    checkDependencies,
-  ];
+  validators() {
+    return [
+      require('../../validators/commands/checkConfigExists').checkConfigExists,
+      require('../../validators/commands/checkBuild').checkApplication,
+      require('../../validators/commands/runMigrationsAndCheckVersions')
+        .runMigrationsAndCheckVersions,
+      require('../../validators/commands/checkDependencies').checkDependencies,
+    ];
+  }
 
   action(parameters) {
     // used require for lazy code execution

package/src/commands/build/build.ts

@@ -5,6 +5,8 @@ import { app } from '../index';
 export default async (context: Context, parameters): Promise<CommandResult> => {
   await app.run('build', parameters);
 
+  // todo builder.getBuildStats and send analytics event "cli:command:build:stats"
+
   return Promise.resolve({
     status: 'ok',
   });