@tramvai/cli 2.64.0 → 2.65.9

package/src/commands/new/templates/child-app/multirepo/tramvai.json.hbs

@@ -5,15 +5,9 @@
       "name": "{{configEntry.name}}",
       "root": "src",
       "type": "child-app",
-      "commands": {
-        "build": {
-          "configurations": {
-            "postcss": {
-              "config": "src/postcss"
-            },
-          }
-        }
-      }
+      "postcss": {
+        "config": "src/postcss"
+      },
     }
   }
 }

package/src/commands/start/command.ts

@@ -83,7 +83,7 @@ export class StartCommand extends CLICommand<Params> {
     {
       name: '--rs, --resolveSymlinks',
       value: '[resolveSymlinks]',
-      transformer: (value) => value !== 'false',
+      transformer: (value: string) => value !== 'false',
       description:
         'Pass value to `resolve.symlinks` in webpack (https://webpack.js.org/configuration/resolve/#resolve-symlinks)`',
     },
@@ -102,7 +102,7 @@ export class StartCommand extends CLICommand<Params> {
     {
       name: '--fileCache',
       value: '[fileCache]',
-      transformer: (value) => value !== 'false',
+      transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
     {

package/src/commands/start-prod/command.ts

@@ -34,7 +34,7 @@ export class StartProdCommand extends CLICommand<Params> {
     {
       name: '--rs, --resolveSymlinks',
       value: '[resolveSymlinks]',
-      transformer: (value) => value !== 'false',
+      transformer: (value: string) => value !== 'false',
       description:
         'Pass value to `resolve.symlinks` in webpack (https://webpack.js.org/configuration/resolve/#resolve-symlinks)`',
     },
@@ -76,7 +76,7 @@ export class StartProdCommand extends CLICommand<Params> {
     {
       name: '--fileCache',
       value: '[fileCache]',
-      transformer: (value) => value !== 'false',
+      transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
     {

package/src/commands/static/application.ts

@@ -11,7 +11,7 @@ import { webpackServerConfig } from '../../library/webpack/application/server/pr
 import type { CommandResult } from '../../models/command';
 import type { ApplicationConfigEntry } from '../../typings/configEntry/application';
 import type { Params } from './command';
-import { ConfigManager } from '../../config/configManager';
+import { createConfigManager } from '../../config/configManager';
 import { request } from './request';
 import { generateStatic } from './generate';
 import { toWebpackConfig } from '../../library/webpack/utils/toWebpackConfig';
@@ -27,7 +27,7 @@ export const staticApp = async (
   configEntry: ApplicationConfigEntry,
   options: Params
 ): Promise<CommandResult> => {
-  const clientConfigManager = new ConfigManager(configEntry, {
+  const clientConfigManager = createConfigManager(configEntry, {
     env: 'production',
     ...options,
     buildType: 'client',
@@ -46,17 +46,8 @@ export const staticApp = async (
     });
   }
 
-  const {
-    name,
-    host,
-    port,
-    staticPort,
-    staticHost,
-    build: {
-      options: { outputClient },
-    },
-  } = serverConfigManager;
-  const root = serverConfigManager.getBuildPath();
+  const { name, host, port, staticPort, staticHost, output } = serverConfigManager;
+  const root = serverConfigManager.buildPath;
 
   context.logger.event({
     type: 'debug',
@@ -76,7 +67,7 @@ export const staticApp = async (
       PORT_SERVER: `${port}`,
       ASSETS_PREFIX:
         process.env.ASSETS_PREFIX ??
-        `http://${staticHost}:${staticPort}/${outputClient.replace(/\/$/, '')}/`,
+        `http://${staticHost}:${staticPort}/${output.client.replace(/\/$/, '')}/`,
     },
   });
 

package/src/commands/static/command.ts

@@ -44,7 +44,7 @@ export class StaticCommand extends CLICommand<Params> {
     {
       name: '--fileCache',
       value: '[fileCache]',
-      transformer: (value) => value !== 'false',
+      transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
     {

package/src/commands/static/generate.ts

@@ -17,8 +17,8 @@ export const generateStatic = async (
   const q = new PQueue(MAX_CONCURRENT);
   const promises = [];
 
-  const { host, port, rootDir, build } = configManager;
-  const staticPath = resolve(rootDir, build.options.outputStatic);
+  const { host, port, rootDir, output } = configManager;
+  const staticPath = resolve(rootDir, output.static);
   const serverPath = `http://${host}:${port}`;
 
   for (const path of paths) {

package/src/commands/static/server.ts

@@ -3,8 +3,11 @@ import express from 'express';
 import compression from 'compression';
 import zlib from 'zlib';
 import type { ConfigManager } from '../../config/configManager';
+import type { ApplicationConfigEntry } from '../../typings/configEntry/application';
 
-export const startServer = (configManager: ConfigManager): Promise<Server> => {
+export const startServer = (
+  configManager: ConfigManager<ApplicationConfigEntry>
+): Promise<Server> => {
   const { port } = configManager;
   const app = express();
 
@@ -22,7 +25,7 @@ export const startServer = (configManager: ConfigManager): Promise<Server> => {
     next();
   });
 
-  app.use('/', express.static(configManager.build.options.outputStatic));
+  app.use('/', express.static(configManager.output.static));
 
   return new Promise((resolve) => {
     const server = app.listen(port, () => {

package/src/commands/static/staticServer.ts

@@ -3,8 +3,11 @@ import express from 'express';
 import compression from 'compression';
 import zlib from 'zlib';
 import type { ConfigManager } from '../../config/configManager';
+import type { ApplicationConfigEntry } from '../../typings/configEntry/application';
 
-export const startStaticServer = (configManager: ConfigManager): Promise<Server> => {
+export const startStaticServer = (
+  configManager: ConfigManager<ApplicationConfigEntry>
+): Promise<Server> => {
   const { staticHost, staticPort } = configManager;
   const app = express();
 
@@ -23,8 +26,8 @@ export const startStaticServer = (configManager: ConfigManager): Promise<Server>
   });
 
   app.use(
-    `/${configManager.build.options.outputClient.replace(/\/$/, '')}/`,
-    express.static(configManager.getBuildPath())
+    `/${configManager.output.client.replace(/\/$/, '')}/`,
+    express.static(configManager.buildPath)
   );
 
   return new Promise((resolve) => {

package/src/commands/update/updatePackageJson.ts

@@ -8,14 +8,14 @@ const isUnifiedVersion = (name: string) => {
   return name.startsWith('@tramvai');
 };
 
-const getVersionFromDep = (dep) => parse(dep)?.version || minVersion(dep)?.version;
+const getVersionFromDep = (dep: string) => parse(dep)?.version || minVersion(dep)?.version;
 
 const updateEntry = async (
   deps: Record<string, any>,
   dep: string,
   { currentVersion, version }: { currentVersion: string; version: string }
 ) => {
-  let nextVersion: string;
+  let nextVersion: string | undefined;
 
   if (isUnifiedVersion(dep) && getVersionFromDep(deps[dep]) === currentVersion) {
     nextVersion = version;
@@ -66,6 +66,10 @@ export const updatePackageJson = async (version: string) => {
   const content = JSON.parse(file.toString());
   const currentVersion = getVersionFromDep(content.dependencies['@tramvai/core']);
 
+  if (!currentVersion) {
+    throw new Error("Couldn't resolve current tramvai version");
+  }
+
   if (currentVersion === version) {
     console.error('The installed version is equal to the current version, no update is required.');
     process.exit(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,130 @@ 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 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 ?? 3000),
+    staticPort: Number(settings.staticPort ?? (type === 'module' ? 4040 : 4000)),
+    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,
   });