@tramvai/cli 2.64.0 → 2.66.0

package/src/api/start/providers/child-app/shared.ts

@@ -1,4 +1,5 @@
 import type { Provider } from '@tinkoff/dippy';
+import { provide } from '@tinkoff/dippy';
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN } from '../../tokens';
 import {
   CONFIG_MANAGER_TOKEN,
@@ -7,74 +8,50 @@ import {
   STATIC_SERVER_TOKEN,
 } from '../../../../di/tokens';
 import type { ChildAppConfigEntry } from '../../../../typings/configEntry/child-app';
-import type { Params } from '../../index';
-import { ConfigManager } from '../../../../config/configManager';
 import { closeWorkerPoolTranspiler } from '../../../../library/webpack/utils/workersPool';
 import { stopServer } from '../../utils/stopServer';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
+import { createConfigManager, DEFAULT_STATIC_MODULE_PORT } from '../../../../config/configManager';
+import { detectPortSync } from '../../../../utils/detectPortSync';
 
 export const sharedProviders: readonly Provider[] = [
-  {
+  provide({
     provide: CONFIG_MANAGER_TOKEN,
-    useFactory: ({
-      configEntry,
-      parameters,
-    }: {
-      configEntry: ChildAppConfigEntry;
-      parameters: Params;
-    }) => {
-      return new ConfigManager(configEntry, {
+    useFactory: ({ configEntry, parameters }) =>
+      createConfigManager(configEntry as ChildAppConfigEntry, {
         ...parameters,
         env: 'development',
-        port: parameters.port ?? 4040,
-        buildType: 'client',
-      });
-    },
+        port: detectPortSync(parameters.port ?? DEFAULT_STATIC_MODULE_PORT),
+      }),
     deps: {
       configEntry: CONFIG_ENTRY_TOKEN,
       parameters: COMMAND_PARAMETERS_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: STATIC_SERVER_TOKEN,
     useFactory: createServer,
-  },
-  {
+  }),
+  provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({
-      staticServer,
-      parameters,
-    }: {
-      staticServer: typeof STATIC_SERVER_TOKEN;
-      parameters: Params;
-    }) => {
+    useFactory: ({ staticServer, configManager }) => {
       return async function staticServerListen() {
-        const { host = 'localhost', port = 4040 } = parameters;
-
-        try {
-          await listenServer(staticServer, host, port);
-        } catch (error) {
-          if ((error as any).code === 'EADDRINUSE') {
-            throw new Error(
-              `Address '${host}:${port}' in use, either release this port or use options --port --host`
-            );
-          }
+        const { host, port } = configManager;
 
-          throw error;
-        }
+        await listenServer(staticServer, host, port);
       };
     },
     deps: {
       staticServer: STATIC_SERVER_TOKEN,
-      parameters: COMMAND_PARAMETERS_TOKEN,
+      configManager: CONFIG_MANAGER_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: CLOSE_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ staticServer }: { staticServer: typeof STATIC_SERVER_TOKEN }) => {
+    useFactory: ({ staticServer }) => {
       return () => {
         return stopServer(staticServer);
       };
@@ -82,11 +59,11 @@ export const sharedProviders: readonly Provider[] = [
     deps: {
       staticServer: STATIC_SERVER_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: CLOSE_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ configManager }: { configManager: typeof CONFIG_MANAGER_TOKEN }) => {
+    useFactory: ({ configManager }) => {
       return async () => {
         await closeWorkerPoolTranspiler(configManager);
       };
@@ -94,5 +71,5 @@ export const sharedProviders: readonly Provider[] = [
     deps: {
       configManager: CONFIG_MANAGER_TOKEN,
     },
-  },
+  }),
 ] as const;

package/src/api/start/providers/module/shared.ts

@@ -1,4 +1,5 @@
 import type { Provider } from '@tinkoff/dippy';
+import { provide } from '@tinkoff/dippy';
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN } from '../../tokens';
 import {
   CONFIG_MANAGER_TOKEN,
@@ -6,75 +7,51 @@ import {
   COMMAND_PARAMETERS_TOKEN,
   STATIC_SERVER_TOKEN,
 } from '../../../../di/tokens';
-import type { ModuleConfigEntry } from '../../../../typings/configEntry/module';
-import type { Params } from '../../index';
-import { ConfigManager } from '../../../../config/configManager';
+import { createConfigManager, DEFAULT_STATIC_MODULE_PORT } from '../../../../config/configManager';
 import { closeWorkerPoolTranspiler } from '../../../../library/webpack/utils/workersPool';
 import { stopServer } from '../../utils/stopServer';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
+import { detectPortSync } from '../../../../utils/detectPortSync';
+import type { ModuleConfigEntry } from '../../../../typings/configEntry/module';
 
 export const sharedProviders: readonly Provider[] = [
-  {
+  provide({
     provide: CONFIG_MANAGER_TOKEN,
-    useFactory: ({
-      configEntry,
-      parameters,
-    }: {
-      configEntry: ModuleConfigEntry;
-      parameters: Params;
-    }) => {
-      return new ConfigManager(configEntry, {
+    useFactory: ({ configEntry, parameters }) =>
+      createConfigManager(configEntry as ModuleConfigEntry, {
         ...parameters,
         env: 'development',
-        port: parameters.port ?? 4040,
-        buildType: 'client',
-      });
-    },
+        port: detectPortSync(parameters.port ?? DEFAULT_STATIC_MODULE_PORT),
+      }),
     deps: {
       configEntry: CONFIG_ENTRY_TOKEN,
       parameters: COMMAND_PARAMETERS_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: STATIC_SERVER_TOKEN,
     useFactory: createServer,
-  },
-  {
+  }),
+  provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({
-      staticServer,
-      parameters,
-    }: {
-      staticServer: typeof STATIC_SERVER_TOKEN;
-      parameters: Params;
-    }) => {
+    useFactory: ({ staticServer, configManager }) => {
       return async function staticServerListen() {
-        const { host = 'localhost', port = 4040 } = parameters;
+        const { host, port } = configManager;
 
-        try {
-          await listenServer(staticServer, host, port);
-        } catch (error) {
-          if ((error as any).code === 'EADDRINUSE') {
-            throw new Error(
-              `Address '${host}:${port}' in use, either release this port or use options --port --host`
-            );
-          }
-
-          throw error;
-        }
+        await listenServer(staticServer, host, port);
       };
     },
     deps: {
       staticServer: STATIC_SERVER_TOKEN,
-      parameters: COMMAND_PARAMETERS_TOKEN,
+      configManager: CONFIG_MANAGER_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: CLOSE_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ staticServer }: { staticServer: typeof STATIC_SERVER_TOKEN }) => {
+    useFactory: ({ staticServer }) => {
       return () => {
         return stopServer(staticServer);
       };
@@ -82,11 +59,11 @@ export const sharedProviders: readonly Provider[] = [
     deps: {
       staticServer: STATIC_SERVER_TOKEN,
     },
-  },
-  {
+  }),
+  provide({
     provide: CLOSE_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ configManager }: { configManager: typeof CONFIG_MANAGER_TOKEN }) => {
+    useFactory: ({ configManager }) => {
       return async () => {
         closeWorkerPoolTranspiler(configManager);
       };
@@ -94,5 +71,5 @@ export const sharedProviders: readonly Provider[] = [
     deps: {
       configManager: CONFIG_MANAGER_TOKEN,
     },
-  },
+  }),
 ] as const;

package/src/api/start/utils/banner.ts

@@ -3,6 +3,7 @@ import type { Container } from '@tinkoff/dippy';
 import { successBox } from '../../../utils/formatting';
 import { UI_SHOW_BANNER_TOKEN, CONFIG_MANAGER_TOKEN, STDOUT_TOKEN } from '../../../di/tokens';
 import { getDocUrl, getTip } from './tips';
+import { isApplication } from '../../../config/validate';
 
 const label = (name) => chalk.bold.cyan(`▸ ${name}:`);
 const link = (url) => chalk.underline.blue(url);
@@ -24,9 +25,9 @@ export function showBanner(di: Container) {
     titleLines.push(`${label('Type')}             ${config.type}`);
   }
   titleLines.push(`${label('Modern')}           ${config.modern}`);
-  titleLines.push(`${label('ReactRefresh')}     ${config.hotRefresh}`);
+  titleLines.push(`${label('ReactRefresh')}     ${config.hotRefresh.enabled}`);
 
-  if (config.build.configurations.fileSystemPages.enable) {
+  if (isApplication(config) && config.fileSystemPages.enabled) {
     titleLines.push(`${label('FileSystemPages')}  true`);
   }
 

package/src/api/start/utils/listenServer.ts

@@ -1,10 +1,11 @@
 import type { Server } from 'net';
 
-export const listenServer = (server: Server, host: string, port: number) => {
+export const listenServer = async (server: Server, host: string, port: number): Promise<void> => {
   return new Promise<void>((resolve, reject) => {
     server.once('error', (error) => {
       reject(error);
     });
+
     server.listen(port, host, () => {
       resolve();
     });

package/src/api/start/utils/tips/tips.ts

@@ -3,6 +3,7 @@ import { existsSync } from 'fs-extra';
 import { sync as resolveSync } from 'resolve';
 import { CONFIG_MANAGER_TOKEN } from '../../../../di/tokens';
 import type { TramvaiTip } from './types';
+import { isApplication } from '../../../../config/validate';
 
 const DEFAULT_ROOT_DIR = process.cwd();
 
@@ -22,10 +23,7 @@ Consider to test out swc support.`,
     isApplicable(di) {
       const configManager = di.get(CONFIG_MANAGER_TOKEN);
 
-      return (
-        configManager.serve.configurations?.experiments?.transpilation?.loader !== 'swc' &&
-        configManager.build.configurations?.experiments?.transpilation?.loader !== 'swc'
-      );
+      return configManager.experiments?.transpilation?.loader !== 'swc';
     },
   },
   {
@@ -43,7 +41,7 @@ Consider to test out swc support.`,
     isApplicable(di) {
       const configManager = di.get(CONFIG_MANAGER_TOKEN);
 
-      return configManager.hotRefresh !== true;
+      return configManager.hotRefresh.enabled !== true;
     },
   },
   {
@@ -53,9 +51,14 @@ It may reduce the boilerplate code required with bundles`,
     isApplicable(di) {
       const configManager = di.get(CONFIG_MANAGER_TOKEN);
       const { rootDir, root } = configManager;
-      const { fileSystemPages } = configManager.build.configurations;
 
-      if (!fileSystemPages.enable) {
+      if (!isApplication(configManager)) {
+        return false;
+      }
+
+      const { fileSystemPages } = configManager;
+
+      if (!fileSystemPages.enabled) {
         return true;
       }
 
@@ -107,7 +110,7 @@ So you can remove alias config from tramvai.json`,
     isApplicable(di) {
       const configManager = di.get(CONFIG_MANAGER_TOKEN);
 
-      return !!configManager.build.configurations?.alias;
+      return !!configManager.alias;
     },
   },
   {

package/src/api/start-prod/providers/application.ts

@@ -8,24 +8,30 @@ import {
   CONFIG_MANAGER_TOKEN,
 } from '../../../di/tokens';
 import type { Params } from '../index';
-import { ConfigManager } from '../../index';
 import type { ConfigEntry } from '../../../typings/configEntry/common';
 import { CLOSE_HANDLER_TOKEN, SERVER_PROCESS_TOKEN } from '../tokens';
 import { DEBUG_ARGV } from '../../../config/constants';
+import { detectPortSync } from '../../../utils/detectPortSync';
 import { safeRequire } from '../../../utils/safeRequire';
+import type { ConfigManager } from '../../../config/configManager';
+import {
+  createConfigManager,
+  DEFAULT_PORT,
+  DEFAULT_STATIC_PORT,
+} from '../../../config/configManager';
+import type { ApplicationConfigEntry } from '../../../typings/configEntry/application';
 
 export const applicationsProviders: readonly Provider[] = [
   provide({
     provide: CONFIG_MANAGER_TOKEN,
-    useFactory: ({ configEntry, parameters }: { configEntry: ConfigEntry; parameters: Params }) => {
-      return new ConfigManager(configEntry, {
+    useFactory: ({ configEntry, parameters }: { configEntry: ConfigEntry; parameters: Params }) =>
+      createConfigManager(configEntry, {
         ...parameters,
         env: 'production',
-        port: parameters.port ?? 3000,
-        staticPort: parameters.staticPort ?? 4000,
         buildType: 'client',
-      });
-    },
+        port: detectPortSync(parameters.port ?? DEFAULT_PORT),
+        staticPort: detectPortSync(parameters.staticPort ?? DEFAULT_STATIC_PORT),
+      }),
     deps: {
       configEntry: CONFIG_ENTRY_TOKEN,
       parameters: COMMAND_PARAMETERS_TOKEN,
@@ -35,19 +41,13 @@ export const applicationsProviders: readonly Provider[] = [
     provide: SERVER_PROCESS_TOKEN,
     useFactory: ({ configManager, parameters }) => {
       const { env } = parameters;
-      const serverConfigManager = configManager.withSettings({
+      const serverConfigManager = (
+        configManager as ConfigManager<ApplicationConfigEntry>
+      ).withSettings({
         buildType: 'server',
       });
-      const {
-        debug,
-        port,
-        staticPort,
-        staticHost,
-        build: {
-          options: { outputClient },
-        },
-      } = serverConfigManager;
-      const root = serverConfigManager.getBuildPath();
+      const { debug, port, staticPort, staticHost, output } = serverConfigManager;
+      const root = serverConfigManager.buildPath;
 
       return fork(path.resolve(root, 'server.js'), [], {
         execArgv: debug ? DEBUG_ARGV : [],
@@ -62,7 +62,7 @@ export const applicationsProviders: readonly Provider[] = [
           PORT_SERVER: `${port}`,
           ASSETS_PREFIX:
             process.env.ASSETS_PREFIX ??
-            `http://${staticHost}:${staticPort}/${outputClient.replace(/\/$/, '')}/`,
+            `http://${staticHost}:${staticPort}/${output.client.replace(/\/$/, '')}/`,
         },
       });
     },

package/src/api/start-prod/providers/child-app.ts

@@ -5,21 +5,20 @@ import {
   CONFIG_ENTRY_TOKEN,
   CONFIG_MANAGER_TOKEN,
 } from '../../../di/tokens';
-import type { Params } from '../index';
-import { ConfigManager } from '../../index';
-import type { ConfigEntry } from '../../../typings/configEntry/common';
+import { createConfigManager, DEFAULT_STATIC_MODULE_PORT } from '../../../config/configManager';
+import type { ChildAppConfigEntry } from '../../../typings/configEntry/child-app';
+import { detectPortSync } from '../../../utils/detectPortSync';
 
 export const childAppProviders: readonly Provider[] = [
   provide({
     provide: CONFIG_MANAGER_TOKEN,
-    useFactory: ({ configEntry, parameters }: { configEntry: ConfigEntry; parameters: Params }) => {
-      return new ConfigManager(configEntry, {
+    useFactory: ({ configEntry, parameters }) =>
+      createConfigManager(configEntry as ChildAppConfigEntry, {
         ...parameters,
         env: 'production',
-        staticPort: parameters.staticPort ?? 4040,
+        staticPort: detectPortSync(parameters.staticPort ?? DEFAULT_STATIC_MODULE_PORT),
         buildType: 'client',
-      });
-    },
+      }),
     deps: {
       configEntry: CONFIG_ENTRY_TOKEN,
       parameters: COMMAND_PARAMETERS_TOKEN,

package/src/api/start-prod/providers/shared.ts

@@ -5,11 +5,7 @@ import fastifyCompress from '@fastify/compress';
 import fastifyStatic from '@fastify/static';
 import zlib from 'zlib';
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN, PROCESS_HANDLER_TOKEN } from '../tokens';
-import {
-  COMMAND_PARAMETERS_TOKEN,
-  CONFIG_MANAGER_TOKEN,
-  STATIC_SERVER_TOKEN,
-} from '../../../di/tokens';
+import { CONFIG_MANAGER_TOKEN, STATIC_SERVER_TOKEN } from '../../../di/tokens';
 import { createServer } from '../../start/utils/createServer';
 import { stopServer } from '../../start/utils/stopServer';
 import { listenServer } from '../../start/utils/listenServer';
@@ -25,19 +21,9 @@ export const sharedProviders: readonly Provider[] = [
     multi: true,
     useFactory: ({ staticServer, configManager }) => {
       return async function staticServerListen() {
-        const { staticHost = 'localhost', staticPort = 4000 } = configManager;
+        const { staticHost, staticPort } = configManager;
 
-        try {
-          await listenServer(staticServer, staticHost.replace('localhost', '0.0.0.0'), staticPort);
-        } catch (error) {
-          if ((error as any).code === 'EADDRINUSE') {
-            throw new Error(
-              `Address '${staticHost}:${staticPort}' in use, either release this port or use options --staticPort --staticHost`
-            );
-          }
-
-          throw error;
-        }
+        await listenServer(staticServer, staticHost.replace('localhost', '0.0.0.0'), staticPort);
       };
     },
     deps: {
@@ -75,12 +61,12 @@ export const sharedProviders: readonly Provider[] = [
 
         if (isApplication(configManager)) {
           await app.register(fastifyStatic, {
-            root: configManager.getBuildPath(),
-            prefix: `/${configManager.build.options.outputClient.replace(/\/$/, '')}/`,
+            root: configManager.buildPath,
+            prefix: `/${configManager.output.client.replace(/\/$/, '')}/`,
           });
         } else if (isChildApp(configManager)) {
           await app.register(fastifyStatic, {
-            root: configManager.getBuildPath(),
+            root: configManager.buildPath,
             prefix: `/${configManager.name}/`,
           });
         }

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

@@ -11,28 +11,35 @@ import type { STATIC_SERVER_TOKEN } from '../../../di/tokens';
 import { CONFIG_ROOT_DIR_TOKEN, UI_OS_NOTIFY_TOKEN } from '../../../di/tokens';
 import { WEBPACK_WATCHING_TOKEN, CLOSE_HANDLER_TOKEN } from '../tokens';
 import { close } from '../../../utils/close';
+import { isApplication, isChildApp, isModule } from '../../../config/validate';
 
 const getPrefix = (configManager: ConfigManager): string => {
-  switch (configManager.type) {
-    case 'application':
-      return '/';
-    case 'child-app':
-      return `/${configManager.name}`;
-    case 'module':
-      return `/${configManager.name}/:version`;
+  if (isApplication(configManager)) {
+    return '/';
+  }
+
+  if (isChildApp(configManager)) {
+    return `/${configManager.name}`;
+  }
+
+  if (isModule(configManager)) {
+    return `/${configManager.name}/:version`;
   }
 
   throw new Error(`${configManager.type} is not supported`);
 };
 
 const getHotModulePrefix = (configManager: ConfigManager): string => {
-  switch (configManager.type) {
-    case 'application':
-      return `/${configManager.build.options.outputClient}`;
-    case 'child-app':
-      return `/${configManager.name}`;
-    case 'module':
-      return `/${configManager.name}/:version`;
+  if (isApplication(configManager)) {
+    return `/${configManager.output.client}`;
+  }
+
+  if (isChildApp(configManager)) {
+    return `/${configManager.name}`;
+  }
+
+  if (isModule(configManager)) {
+    return `/${configManager.name}/:version`;
   }
 
   throw new Error(`${configManager.type} is not supported`);
@@ -78,7 +85,7 @@ export const createDevServer = ({
       },
     });
 
-    if (configManager.hotRefresh) {
+    if (configManager.hotRefresh.enabled) {
       app.use(getHotModulePrefix(configManager), webpackHotMiddleware(compiler, { log: false }));
     }
 

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

@@ -1,7 +1,7 @@
 import type webpack from 'webpack';
 import WebpackBuildNotifierPlugin from 'webpack-build-notifier';
 import type { ConfigManager } from '../../../config/configManager';
-import type { ApplicationConfigEntry } from '../../../typings/configEntry/application';
+import type { CliConfigEntry } from '../../../typings/configEntry/cli';
 
 const getStatsByType = (stats: webpack.MultiStats, type: string) => {
   return stats.stats.find((st) => {
@@ -11,21 +11,21 @@ const getStatsByType = (stats: webpack.MultiStats, type: string) => {
 
 export const notifier = (
   compiler: webpack.MultiCompiler,
-  configManager: ConfigManager<ApplicationConfigEntry>
+  configManager: ConfigManager<CliConfigEntry>
 ) => {
   const clientNotifier = new WebpackBuildNotifierPlugin({
     successSound: false,
     warningSound: false,
-    ...configManager.serve?.notifications,
-    ...configManager.serve?.notifications?.client,
+    ...configManager.notifications,
+    ...configManager.notifications?.client,
   });
   const serverNotifier = new WebpackBuildNotifierPlugin({
     // отлкючаем нотификацию для одного из нотификатора, чтобы не дублировать
     suppressSuccess: 'always',
     successSound: false,
     warningSound: false,
-    ...configManager.serve?.notifications,
-    ...configManager.serve?.notifications?.server,
+    ...configManager.notifications,
+    ...configManager.notifications?.server,
   });
 
   compiler.hooks.done.tap('webpack-build-notifier', (stats) => {

package/src/builder/webpack/devServer/pool/process/pool.ts

@@ -22,7 +22,7 @@ export const ProcessWorkerBridge: WorkerBridgeFactory<Worker> = (di) => {
       cluster.setupMaster({
         // указываем другой файл для работы cluster.fork
         exec: path.resolve(__dirname, './worker.js'),
-        execArgv: [].concat(
+        execArgv: ([] as string[]).concat(
           configManager.debug ? DEBUG_ARGV : [],
           configManager.trace ? TRACE_ARGV : []
         ),
@@ -43,8 +43,8 @@ export const ProcessWorkerBridge: WorkerBridgeFactory<Worker> = (di) => {
         PORT_SERVER: `${configManager.port}`,
       });
 
-      worker.process.stdout.pipe(stdout);
-      worker.process.stderr.pipe(stderr);
+      worker.process.stdout?.pipe(stdout);
+      worker.process.stderr?.pipe(stderr);
 
       return worker;
     },

package/src/builder/webpack/devServer/pool/thread/pool.ts

@@ -15,6 +15,13 @@ export const ThreadWorkerBridge: WorkerBridgeFactory<Worker> = (di) => {
       // WARN: potentially dangerous code that will lead to bugs in case of run parallel builds from once process
       // as nodejs do not support this for threads - https://github.com/nodejs/node/issues/41673
       // but it is not a very popular usage anyway
+      // Found issues:
+      // 1. babel-plugin-lodash will reload configs when the cwd is changed
+      // and if this happens between file compilations
+      // it'll lead to obscure errors inside this plugin as it won't resolve
+      // previously resolved modules and there will be the mess
+      // [source code](https://github.com/lodash/babel-plugin-lodash/blob/master/src/config.js#L18)
+      // but it currently affects only jest tests probably because of jest's workers usage
       process.chdir(di.get(CONFIG_ROOT_DIR_TOKEN));
 
       const worker = new Worker(path.resolve(__dirname, './worker.js'), {

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

@@ -59,9 +59,13 @@ export const serverRunner = ({
     const file = `${Object.keys(config.entryPoints.entries())[0]}.js`;
     const filename = path.resolve(config.output.get('path'), file);
     // настоящая ссылка на файл используется для отладки в debug режиме
-    const realFilename = `http://${configManager.staticHost}:${configManager.staticPort}/${configManager.build.options.outputServer}/${file}`;
+    const realFilename = `http://${configManager.staticHost}:${configManager.staticPort}/${configManager.output.server}/${file}`;
     const serverCompiler = compiler.compilers.find((comp) => comp.name === 'server');
 
+    if (!serverCompiler) {
+      throw new Error('Server compiler has not found');
+    }
+
     const fs = serverCompiler.outputFileSystem as any;
     // ThreadWorkerPool is experimental
     // it doesn't work well when running integration tests in tramvai repo
@@ -76,11 +80,11 @@ export const serverRunner = ({
         ? ThreadWorkerBridge
         : ProcessWorkerBridge
     );
-    let worker: Worker;
+    let worker: Worker | null;
     let serverInvalidated = true;
-    let workerPort: number;
-    let resolveWorkerPort: () => void;
-    let workerPortPromise: Promise<void>;
+    let workerPort: number | null;
+    let resolveWorkerPort: () => void | null;
+    let workerPortPromise: Promise<void> | null;
     let hasExitedUnexpectedly = false;
 
     const proxy = createProxyServer({
@@ -248,8 +252,11 @@ export const serverRunner = ({
           workerPort = null;
           workerPortPromise = null;
 
+          if (worker) {
+            pool.release(worker);
+          }
+
           worker = null;
-          pool.release(worker);
 
           console.error(EXITED_UNEXPECTEDLY);
         });