@tramvai/cli 2.147.1 → 2.148.1

package/src/commands/createApp.ts

@@ -8,6 +8,7 @@ import {
   configProviders,
   packageManagerProviders,
   stdProviders,
+  networkProviders,
 } from '../di/providers';
 import { COMMAND_MAP_TOKEN, COMMAND_PARAMETERS_TOKEN, COMMAND_RUNNER_TOKEN } from '../di/tokens';
 
@@ -25,6 +26,7 @@ export const createApp = ({
     ...commandsProviders,
     ...packageManagerProviders,
     ...builderProviders,
+    ...networkProviders,
     ...providers,
     {
       provide: COMMAND_PARAMETERS_TOKEN,

package/src/commands/static/application.ts

@@ -17,6 +17,7 @@ import { startStaticServer } from './staticServer';
 import { startServer } from './server';
 import { handleServerOutput } from './utils/handle-server-output';
 import { appBundleInfo } from '../../utils/dev-app/request';
+import { PortManager } from '../../models/port-manager';
 
 // eslint-disable-next-line max-statements
 export const staticApp = async (
@@ -24,11 +25,17 @@ export const staticApp = async (
   configEntry: ApplicationConfigEntry,
   options: Params
 ): Promise<CommandResult> => {
+  const network = new PortManager({ configEntry, commandParams: options });
+
+  await network.computeAvailablePorts();
+
   const clientConfigManager = createConfigManager(configEntry, {
     env: 'production',
     ...options,
     buildType: 'client',
     modern: false,
+    port: network.port,
+    staticPort: network.staticPort,
   });
   const serverConfigManager = clientConfigManager.withSettings({ buildType: 'server' });
 

package/src/config/configManager.ts

@@ -13,6 +13,7 @@ import moduleVersion from '../utils/moduleVersion';
 import { packageVersion } from '../utils/packageVersion';
 import { showConfig } from './showConfig';
 import type { Target } from '../typings/target';
+import { PortManager } from '../models/port-manager';
 
 // @TODO: maybe split settings depending on env?
 export interface Settings<E extends Env> {
@@ -92,10 +93,7 @@ export type ConfigManager<
     assetsPrefix?: string;
   };
 
-export const DEFAULT_PORT = 3000;
 export const DEFAULT_STATIC_HOST = 'localhost';
-export const DEFAULT_STATIC_PORT = 4000;
-export const DEFAULT_STATIC_MODULE_PORT = 4040;
 
 // eslint-disable-next-line max-statements, complexity
 export const createConfigManager = <C extends ConfigEntry = ConfigEntry, E extends Env = Env>(
@@ -153,10 +151,13 @@ export const createConfigManager = <C extends ConfigEntry = ConfigEntry, E exten
     rootDir,
     buildType,
     debug,
-    port: Number(settings.port ?? DEFAULT_PORT),
+    port: Number(settings.port ?? PortManager.DEFAULT_PORT),
     staticHost: settings.staticHost ?? DEFAULT_STATIC_HOST,
     staticPort: Number(
-      settings.staticPort ?? (type === 'module' ? DEFAULT_STATIC_MODULE_PORT : DEFAULT_STATIC_PORT)
+      settings.staticPort ??
+        (type === 'module'
+          ? PortManager.DEFAULT_MODULE_STATIC_PORT
+          : PortManager.DEFAULT_STATIC_PORT)
     ),
     modern,
     // eslint-disable-next-line no-nested-ternary

package/src/di/providers/config.ts

@@ -57,7 +57,7 @@ export const configProviders: readonly Provider[] = [
       const { content, isSuccessful } = getTramvaiConfig(rootDir);
 
       if (!isSuccessful) {
-        throw new Error('Config neither passed as parameter or found in file system');
+        throw new Error('Config neither passed as parameter nor found in file system');
       }
 
       const manager = new ConfigManager({ config: content, syncConfigFile: syncJsonFile });

package/src/di/providers/index.ts

@@ -4,3 +4,4 @@ export * from './config';
 export * from './commands';
 export * from './packageManager';
 export * from './builder';
+export * from './network';

package/src/di/providers/network.ts

@@ -0,0 +1,16 @@
+import { provide } from '@tinkoff/dippy';
+import type { Provider } from '@tinkoff/dippy';
+
+import { COMMAND_PARAMETERS_TOKEN, CONFIG_ENTRY_TOKEN, PORT_MANAGER_TOKEN } from '../tokens';
+import { PortManager } from '../../models/port-manager';
+
+export const networkProviders: readonly Provider[] = [
+  provide({
+    provide: PORT_MANAGER_TOKEN,
+    useClass: PortManager,
+    deps: {
+      configEntry: CONFIG_ENTRY_TOKEN,
+      commandParams: COMMAND_PARAMETERS_TOKEN,
+    },
+  }),
+] as const;

package/src/di/tokens/index.ts

@@ -7,3 +7,4 @@ export * from './config';
 export * from './packageManager';
 export * from './builder';
 export * from './server';
+export * from './network';

package/src/di/tokens/network.ts

@@ -0,0 +1,5 @@
+import { createToken } from '@tinkoff/dippy';
+
+import type { PortManager } from '../../models/port-manager';
+
+export const PORT_MANAGER_TOKEN = createToken<PortManager>('portManager');

package/src/library/webpack/utils/threadLoader.ts

@@ -23,7 +23,7 @@ const createWorkerPoolConfig = (configManager: ConfigManager<CliConfigEntry>) =>
 
 const isApplicable = (configManager: ConfigManager<CliConfigEntry>) => {
   return (
-    // thread-loader uses child_process.fork underhood, and sometimes (50/50) work in these processes does not get into inspector.Session profile
+    // thread-loader uses child_process.fork under the hood, and sometimes (50/50) work in these processes does not get into inspector.Session profile
     !process.env.TRAMVAI_CPU_PROFILE &&
     // TODO: check that there is still issue with windows systems and thread-loader
     process.platform !== 'win32' &&

package/src/models/config.spec.ts

@@ -440,3 +440,86 @@ it('should populate defaults for overridable options', () => {
     }
   `);
 });
+
+it('should throw an error if added aditional unknown property', () => {
+  const config: any = {
+    projects: {
+      app: {
+        unknownOption: 'something',
+        name: 'test-app',
+        root: 'src',
+        type: 'application',
+        output: {
+          client: 'assets/compiled',
+        },
+        sourceMap: false,
+        externals: ['test'],
+        fileSystemPages: { enabled: true },
+        experiments: {
+          webpack: {
+            backCompat: true,
+          },
+          transpilation: {
+            loader: {
+              development: 'swc',
+            },
+          },
+        },
+        dedupe: {
+          strategy: 'semver',
+        },
+        define: {
+          shared: {
+            'process.env.APP_ID': 'app',
+          },
+        },
+        svgo: {
+          plugins: [
+            {
+              name: 'test-plugin',
+            },
+          ],
+        },
+      },
+      'child-app': {
+        name: 'test-child-app',
+        root: 'packages/child-app',
+        type: 'child-app',
+        sourceMap: {
+          development: true,
+        },
+        experiments: {
+          transpilation: {
+            loader: {},
+          },
+        },
+        define: {
+          shared: {
+            commonProp: 'unknown',
+          },
+          production: {
+            'process.env.PROD': 'true',
+          },
+        },
+        webpack: {
+          resolveAlias: {
+            stream: 'browser-stream',
+          },
+          provide: {
+            Buffer: ['buffer', 'Buffer'],
+          },
+        },
+      },
+    },
+  };
+
+  expect.assertions(2);
+  try {
+    const configManager = new ConfigManager({ config, syncConfigFile });
+  } catch (e: any) {
+    // eslint-disable-next-line jest/no-conditional-expect
+    expect(e.message).toMatch('Config validation failed');
+    // eslint-disable-next-line jest/no-conditional-expect
+    expect(true).toBeTruthy();
+  }
+});

package/src/models/config.ts

@@ -81,9 +81,15 @@ export class ConfigManager {
       configParameters.projects[projectName] = merge(projectsConfig, entry);
     });
 
-    const ajv = new Ajv({ useDefaults: true });
+    const ajv = new Ajv({
+      useDefaults: true,
+      allowUnionTypes: true,
+      strict: true,
+      strictSchema: false,
+    });
 
-    ajv.addKeyword('cli_overridable', {
+    ajv.addKeyword({
+      keyword: 'cli_overridable',
       modifying: true,
       errors: false,
       validate(schemaValue, currentValue, propSchema) {

package/src/models/port-manager.ts

@@ -0,0 +1,79 @@
+import detectPort from 'detect-port';
+
+import type { ConfigEntry } from '../typings/configEntry/common';
+import type { Params as StartParams } from '../api/start';
+import type { Params as StartProdParams } from '../api/start-prod';
+
+interface NetworkConstructorPayload {
+  configEntry: ConfigEntry;
+  commandParams: StartParams | StartProdParams;
+}
+
+export class PortManager {
+  static DEFAULT_PORT = 3000;
+  static DEFAULT_MODULE_PORT = 4040;
+  static DEFAULT_STATIC_PORT = 4000;
+  static DEFAULT_MODULE_STATIC_PORT = 4040;
+
+  private configEntry: ConfigEntry;
+  private commandParams: StartParams | StartProdParams;
+
+  public port: number | null = null;
+  public staticPort: number | null = null;
+
+  constructor({ configEntry, commandParams }: NetworkConstructorPayload) {
+    this.configEntry = configEntry;
+    this.commandParams = commandParams;
+  }
+
+  /**
+   * Try to detect port considering the fact, that if user requests
+   * a port explicitly, we should not try to detect a free one.
+   *
+   * Also, handle zero port (it means any random port) as the edge case,
+   * because we must pass a final number to the config manager.
+   */
+  public async computeAvailablePorts(): Promise<void> {
+    if (this.commandParams.port !== undefined && this.commandParams.port !== 0) {
+      // @ts-expect-error There is a string actually
+      this.port = parseInt(this.commandParams.port, 10);
+    }
+
+    if (this.commandParams.staticPort !== undefined && this.commandParams.staticPort !== 0) {
+      // @ts-expect-error There is a string actually
+      this.staticPort = parseInt(this.commandParams.staticPort, 10);
+    }
+
+    switch (this.configEntry.type) {
+      case 'child-app':
+        await this.forChildApp();
+        break;
+
+      case 'module':
+        await this.forModule();
+        break;
+
+      case 'application':
+        await this.forApplication();
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  private async forApplication(): Promise<void> {
+    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_PORT));
+    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_STATIC_PORT));
+  }
+
+  private async forModule(): Promise<void> {
+    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_MODULE_PORT));
+    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  }
+
+  private async forChildApp(): Promise<void> {
+    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_MODULE_PORT));
+    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  }
+}

package/src/schema/topLevelSchema.js

@@ -19,6 +19,7 @@ module.exports = (autogeneratedSchema) => {
         patternProperties: {
           '^[$a-zA-Z_-][0-9a-zA-Z_$-]*$': {
             if: {
+              type: 'object',
               properties: {
                 type: { const: 'application' },
               },
@@ -26,6 +27,7 @@ module.exports = (autogeneratedSchema) => {
             then: autogeneratedSchema.properties.application,
             else: {
               if: {
+                type: 'object',
                 properties: {
                   type: { const: 'module' },
                 },
@@ -33,6 +35,7 @@ module.exports = (autogeneratedSchema) => {
               then: autogeneratedSchema.properties.module,
               else: {
                 if: {
+                  type: 'object',
                   properties: {
                     type: { const: 'child-app' },
                   },

package/src/schema/tramvai.spec.ts

@@ -9,7 +9,7 @@ jest.mock('resolve');
 
 describe('JSON schema для tramvai.json', () => {
   it('Схема успешно компилируется', () => {
-    const ajv = new Ajv();
+    const ajv = new Ajv({ strict: true, strictSchema: false, allowUnionTypes: true });
 
     expect(() => ajv.compile(schema)).not.toThrow();
   });
@@ -35,7 +35,13 @@ describe('JSON schema для tramvai.json', () => {
 
     const originalConfig = clone(config);
 
-    const ajv = new Ajv({ allErrors: true, useDefaults: true, strictDefaults: 'log' });
+    const ajv = new Ajv({
+      allErrors: true,
+      useDefaults: true,
+      strict: true,
+      strictSchema: false,
+      allowUnionTypes: true,
+    });
     const validate = ajv.compile(schema);
     const valid = validate(config);
 

package/src/utils/detectPortSync.ts

@@ -1,24 +0,0 @@
-import { execSync } from 'child_process';
-import stripAnsi from 'strip-ansi';
-
-interface Payload {
-  request?: number;
-  fallback: number;
-}
-
-/**
- * Try to detect port synchronously considering the fact, that if user requests
- * a port explicitly, we should not try to detect a free one.
- *
- * Also, handle zero port (it means any random port) as the edge case,
- * because we must pass a final number to the config manager.
- */
-export const detectPortSync = ({ request, fallback }: Payload): number => {
-  if (request !== undefined && request !== 0) {
-    return request;
-  }
-
-  const commandResult = execSync(`npx detect-port ${request ?? fallback}`, { encoding: 'utf-8' });
-
-  return parseInt(stripAnsi(commandResult.toString()), 10);
-};