@tramvai/cli 5.22.0 → 5.40.0

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

@@ -1,5 +1,7 @@
 import noop from '@tinkoff/utils/function/noop';
 import eachObj from '@tinkoff/utils/object/each';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
 import path from 'path';
 import type webpack from 'webpack';
 import type Config from 'webpack-chain';
@@ -72,6 +74,7 @@ export const serverRunner = ({
     }
 
     const fs = serverCompiler.outputFileSystem as any;
+
     // ThreadWorkerPool is experimental
     // it doesn't work well when running integration tests in tramvai repo
     // mostly because of the some problems with `babel-plugin-lodash`
@@ -85,6 +88,7 @@ export const serverRunner = ({
         ? ThreadWorkerBridge
         : ProcessWorkerBridge
     );
+
     let worker: Worker | null;
     let serverInvalidated = true;
     let workerPort: number | null;
@@ -260,14 +264,14 @@ export const serverRunner = ({
       }
     });
 
-    compiler.hooks.done.tap(HOOK_NAME, async (stats) => {
+    async function runWorker(stats?: any) {
       if (serverInvalidated) {
         workerPort = null;
         workerPortPromise = null;
 
         serverInvalidated = false;
 
-        if (stats.hasErrors()) {
+        if (stats?.hasErrors()) {
           // всплыли ошибки при сборке - просто игнорим калбек чтобы не падать ниже и дать возможность выполнить пересборку
           return;
         }
@@ -313,6 +317,38 @@ export const serverRunner = ({
 
         await send(worker, 'script', { filename: realFilename, script });
       }
+    }
+
+    // отключаем watch за при выключенном rebuild
+    if (!configManager.noServerRebuild) {
+      const watchedFileName = 'env.development.js';
+      try {
+        const envPath = path.resolve(process.cwd(), watchedFileName);
+        const watchHandler = (_changedFilePath) => {
+          console.log(chalk.yellow(`${envPath} changed, restart server...`));
+          serverInvalidated = true;
+          runWorker();
+        };
+
+        const watcher = chokidar.watch(envPath);
+        watcher.on('change', watchHandler);
+
+        di.register({
+          provide: CLOSE_HANDLER_TOKEN,
+          multi: true,
+          useValue: () => {
+            watcher.close();
+          },
+        });
+      } catch (err) {
+        console.error(
+          `Something went wrong while watching for changes in ${watchedFileName}: ${err}`
+        );
+      }
+    }
+
+    compiler.hooks.done.tap(HOOK_NAME, async (stats) => {
+      runWorker(stats);
     });
   };
 };

package/src/cli/CLI.ts

@@ -49,8 +49,7 @@ export class CLI {
     config: ConfigManager,
     analytics: Analytics,
     cliRootDir: string,
-    cliPackageManager: PackageManager,
-    packageManager: PackageManager
+    cliPackageManager: PackageManager
   ) {
     this.context = new Context(
       config,
@@ -58,7 +57,6 @@ export class CLI {
       analytics,
       cliRootDir,
       cliPackageManager,
-      packageManager,
       this.runTask,
       this.runCommand,
       this.getTasks,

package/src/cli/index.ts

@@ -77,7 +77,6 @@ export async function cliInitialized(cliArgs = process.argv) {
     });
 
     const configManager = new ConfigManager({ config, syncConfigFile: syncJsonFile });
-    const packageManager = resolvePackageManager({ rootDir: process.cwd() });
 
     const cliRootDir = path.resolve(__dirname, '../', '../');
     const cliPackageManager = new NpmPackageManager({
@@ -91,8 +90,7 @@ export async function cliInitialized(cliArgs = process.argv) {
       configManager,
       analytic,
       cliRootDir,
-      cliPackageManager,
-      packageManager
+      cliPackageManager
     );
 
     return await cliInstance.run(cliArgs);

package/src/commands/add/add.ts

@@ -3,13 +3,18 @@ import type { CommandResult } from '../../models/command';
 import { migrate } from '../../utils/commands/dependencies/migrate';
 import { findTramvaiVersion } from '../../utils/commands/dependencies/findTramvaiVersion';
 import { checkVersions } from '../../utils/commands/dependencies/checkVersions';
+import { getWorkspaceRootByAppName } from '../../utils/commands/dependencies/getWorkspaceRootByAppName';
 
 export type Params = {
-  packageName: string;
+  packageNames: string | string[];
   dev?: boolean;
+  app?: string;
 };
 
-export default async (context: Context, { packageName, dev }: Params): Promise<CommandResult> => {
+export default async (
+  context: Context,
+  { packageNames, dev, app }: Params
+): Promise<CommandResult> => {
   const version = await findTramvaiVersion();
 
   if (!version) {
@@ -18,10 +23,19 @@ export default async (context: Context, { packageName, dev }: Params): Promise<C
     );
   }
 
+  const workspace = app ? getWorkspaceRootByAppName(context, app) : undefined;
+
+  if (workspace && !context.packageManager.isWorkspaceExists(workspace)) {
+    throw new Error(
+      `Workspace ${workspace} for app ${app} is not exists. Check your package.json and tramvai.json`
+    );
+  }
+
   await context.packageManager.install({
-    name: packageName,
+    packageNames,
     version,
     devDependency: dev,
+    workspace,
     stdio: 'inherit',
   });
 

package/src/commands/add/checkPackageValidator.ts

@@ -1,8 +1,12 @@
 import latestVersion from 'latest-version';
 import type { Params } from './add';
 
-export const checkPackage = async (_, { packageName }: Params) => {
-  await latestVersion(packageName);
+export const checkPackage = async (_, { packageNames }: Params) => {
+  if (Array.isArray(packageNames)) {
+    await Promise.all(packageNames.map((packageName) => latestVersion(packageName)));
+  } else {
+    await latestVersion(packageNames);
+  }
 
   return {
     name: 'checkPackage',

package/src/commands/add/command.ts

@@ -7,13 +7,18 @@ class AddCommand extends CLICommand {
 
   description = 'Tramvai package install command';
 
-  command = 'add <packageName>';
+  command = 'add <packageNames...>';
 
   options = [
     {
       name: '-D, --dev',
       description: 'Save package to devDependencies',
     },
+    {
+      name: '-a, --app',
+      value: '[app]',
+      description: 'Install package in app-specific workspace',
+    },
   ];
 
   alias = '';

package/src/commands/new/new.ts

@@ -1,6 +1,7 @@
 import path from 'path';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
+import { packageManagerFactory } from '@tinkoff/package-manager-wrapper';
 import type { Context } from '../../models/context';
 import type { CommandResult } from '../../models/command';
 import type { Params } from './typings';
@@ -64,41 +65,53 @@ export default async function createNew(context: Context, params: Params): Promi
   const templateDir = getPathToTemplate(type, template);
   const sharedDir = getPathToShared();
   const blockDir = getPathToBlock(type);
-  const isNpm = packageManager === 'npm';
-  const isYarn = packageManager === 'yarn';
-  const isJest = testingFramework === 'jest';
-
+  const isMonorepo = template === 'monorepo';
+  const baseDir = type === 'app' ? 'apps' : 'child-apps';
   const blockDirectoryName = {
-    monorepo: path.join(type === 'app' ? 'apps' : 'child-apps', name),
+    monorepo: path.join(baseDir, name),
     multirepo: 'src',
   }[template];
 
-  await renderTemplate(templateDir, directoryName, { configEntry, isJest, isNpm, isYarn });
-  await renderTemplate(sharedDir, directoryName, { configEntry, isJest, isNpm, isYarn });
-  await renderTemplate(blockDir, path.join(directoryName, blockDirectoryName), {
+  const templateData = {
     configEntry,
-    isJest,
-    isNpm,
-    isYarn,
-  });
+    isJest: testingFramework === 'jest',
+    isNpm: packageManager === 'npm',
+    isYarn: packageManager === 'yarn',
+    workspaceBaseDir: isMonorepo ? baseDir : undefined,
+  };
+
+  await renderTemplate(templateDir, directoryName, templateData);
+  await renderTemplate(sharedDir, directoryName, templateData);
+  await renderTemplate(blockDir, path.join(directoryName, blockDirectoryName), templateData);
   if (template === 'monorepo') {
     const monorepoBlockDir = getPathToMonorepoBlock();
 
-    await renderTemplate(monorepoBlockDir, path.join(directoryName, blockDirectoryName), {
-      configEntry,
-      isJest,
-    });
+    await renderTemplate(
+      monorepoBlockDir,
+      path.join(directoryName, blockDirectoryName),
+      templateData
+    );
   }
 
   if (testingFramework !== 'none') {
-    await renderTemplate(getPathToTestingFramework(type, testingFramework), directoryName, {
-      configEntry,
-      isJest,
-    });
+    await renderTemplate(
+      getPathToTestingFramework(type, testingFramework),
+      directoryName,
+      templateData
+    );
   }
 
   await initializationGit(directoryName);
-  await installDependencies({ localDir: directoryName, type, packageManager, testingFramework });
+  await installDependencies({
+    localDir: directoryName,
+    type,
+    packageManager: packageManagerFactory(
+      { rootDir: path.resolve(process.cwd(), directoryName) },
+      packageManager
+    ),
+    testingFramework,
+    workspace: isMonorepo ? blockDirectoryName : undefined,
+  });
 
   console.log(
     `\n\n Project ${name} has been successfully created. To run the project, enter in the terminal`,

package/src/commands/new/steps/installDependencies.ts

@@ -1,7 +1,5 @@
-import type { Options } from 'execa';
-import execa from 'execa';
 import chalk from 'chalk';
-import type { PackageManagers } from '../questions/packageManager';
+import type { InstallOptions, PackageManager } from '@tinkoff/package-manager-wrapper';
 import type { TestingFrameworks } from '../questions/testingFramework';
 import type { Type } from '../questions/type';
 
@@ -57,7 +55,6 @@ const devDependencies = [
   '@tinkoff/eslint-config',
   '@tinkoff/eslint-config-react',
   '@tinkoff/eslint-plugin-tramvai',
-  '@tramvai/cli',
   '@types/react',
   'postcss-custom-media',
   'postcss-custom-properties',
@@ -69,56 +66,107 @@ const devDependencies = [
   'typescript',
 ];
 
-const packagesInstallCommands: Record<PackageManagers, { deps: string[]; devDeps: string[] }> = {
-  npm: {
-    deps: ['install', '--save', '--package-lock', '--legacy-peer-deps'],
-    devDeps: ['install', '--save-dev', '--legacy-peer-deps'],
-  },
-  yarn: {
-    deps: ['add'],
-    devDeps: ['add', '--dev'],
-  },
-  pnpm: {
-    deps: ['add'],
-    devDeps: ['add', '--save-dev'],
-  },
+const rootDependencies = {
+  devDependencies: ['@tramvai/cli'],
+  dependencies: [],
 };
 
+function getBaseDeps(type: Type, isDev: boolean) {
+  const depsMap = DEPS[type];
+  const jestDeps = depsMap.jestDevDependencies;
+  const baseDeps = isDev ? devDependencies : depsMap.dependencies;
+  const rootDeps = rootDependencies[isDev ? 'devDependencies' : 'dependencies'];
+
+  return { rootDeps, baseDeps, jestDeps };
+}
+
+function getDeps(type: Type, options?: { isDev?: boolean; isRoot?: boolean }) {
+  const { rootDeps, baseDeps } = getBaseDeps(type, options?.isDev);
+
+  return [...rootDeps, ...baseDeps];
+}
+
+function getDepsWorkspace(type: Type, options?: { isDev?: boolean; isRoot?: boolean }) {
+  const { rootDeps, baseDeps } = getBaseDeps(type, options?.isDev);
+
+  if (options?.isRoot) {
+    return rootDeps;
+  }
+
+  return baseDeps;
+}
+
+function jestDeps(type: Type) {
+  return getBaseDeps(type, true).jestDeps;
+}
+
 export async function installDependencies({
   localDir,
   type,
   packageManager,
   testingFramework,
+  workspace,
 }: {
   localDir: string;
   type: Type;
-  packageManager: PackageManagers;
+  packageManager: PackageManager;
   testingFramework: TestingFrameworks;
+  workspace?: string;
 }) {
-  const installCommands = packagesInstallCommands[packageManager];
-  const options: Options = {
+  const deps = workspace ? getDepsWorkspace : getDeps;
+
+  const options: InstallOptions = {
     cwd: localDir,
     env: {
       SKIP_TRAMVAI_MIGRATIONS: 'true',
     },
     stdio: 'inherit',
+    workspace,
   };
 
+  // Install cli and core packages into the root of repository if using workspaces for update command to work correctly
+  if (workspace !== undefined) {
+    console.log(`${chalk.blue('[DEPENDENCIES]')} Installing root dependencies`);
+
+    await packageManager.install({
+      packageNames: deps(type, { isDev: true, isRoot: true }),
+      devDependency: true,
+      ...options,
+      workspace: undefined,
+    });
+
+    console.log(`${chalk.blue('[DEPENDENCIES]')} Installing root dev dependencies`);
+
+    await packageManager.install({
+      packageNames: deps(type, { isDev: false, isRoot: true }),
+      devDependency: false,
+      ...options,
+      workspace: undefined,
+    });
+  }
+
   console.log(`${chalk.blue('[DEPENDENCIES]')} Installing app dependencies`);
 
-  await execa(packageManager, [...installCommands.deps, ...DEPS[type].dependencies], options);
+  await packageManager.install({
+    packageNames: deps(type),
+    ...options,
+  });
 
   console.log(`${chalk.blue('[DEPENDENCIES]')} Installing dev dependencies`);
 
-  await execa(packageManager, [...installCommands.devDeps, ...devDependencies], options);
+  await packageManager.install({
+    packageNames: deps(type, { isDev: true }),
+    devDependency: true,
+    ...options,
+  });
 
   if (testingFramework === 'jest') {
     console.log(`${chalk.blue('[DEPENDENCIES]')} Installing jest dependencies`);
 
-    await execa(
-      packageManager,
-      [...installCommands.devDeps, ...DEPS[type].jestDevDependencies],
-      options
-    );
+    await packageManager.install({
+      packageNames: jestDeps(type),
+      devDependency: true,
+      ...options,
+    });
   }
 }

package/src/commands/new/templates/monorepo-block/package.json.hbs

@@ -0,0 +1,5 @@
+{
+  "name": "{{configEntry.name}}",
+  "version": "0.0.0-stub",
+  "private": true
+}

package/src/commands/new/templates/shared/package.json.hbs

@@ -22,5 +22,6 @@
     "*.{js,jsx,ts,tsx}": [
       "eslint --fix"
     ]
-  }
+  }{{#if workspaceBaseDir}},
+  "workspaces": ["{{workspaceBaseDir}}/*"]{{/if}}
 }

package/src/commands/update/update.ts

@@ -4,6 +4,8 @@ import { getLatestPackageVersion } from '../../utils/commands/dependencies/getLa
 import { migrate } from '../../utils/commands/dependencies/migrate';
 import { updatePackageJson } from './updatePackageJson';
 import { checkVersions } from '../../utils/commands/dependencies/checkVersions';
+import moduleVersion from '../../utils/moduleVersion';
+import { findTramvaiVersion } from '../../utils/commands/dependencies/findTramvaiVersion';
 
 export type Params = {
   to: string;
@@ -13,15 +15,36 @@ export default async (
   context: Context,
   { to: version = 'latest' }: Params
 ): Promise<CommandResult> => {
-  const versionNumber = await getLatestPackageVersion('@tramvai/core', version);
+  const targetVersion = await getLatestPackageVersion('@tramvai/cli', version);
+  const currentVersion = await findTramvaiVersion();
+
+  if (!currentVersion) {
+    throw new Error(
+      'Could not resolve tramvai version from package.json. Do you have @tramvai/core installed?'
+    );
+  }
+
+  if (currentVersion === version) {
+    throw new Error(
+      'The installed version is equal to the current version, no update is required.'
+    );
+  }
 
   context.logger.event({
     type: 'info',
     event: 'resolving-version',
-    message: `Tramvai version resolved to ${versionNumber}`,
+    message: `Tramvai version resolved to ${targetVersion}`,
   });
 
-  await updatePackageJson(versionNumber, version === 'prerelease');
+  if (context.packageManager.workspaces) {
+    await Promise.all(
+      context.packageManager.workspaces.map((directory) =>
+        updatePackageJson(targetVersion, currentVersion, version === 'prerelease', directory)
+      )
+    );
+  }
+
+  await updatePackageJson(targetVersion, currentVersion, version === 'prerelease');
 
   context.logger.event({
     type: 'info',

package/src/commands/update/updatePackageJson.spec.ts

@@ -1,8 +1,12 @@
+import { resolve } from 'path';
 import { updatePackageJson } from './updatePackageJson';
 
 const LATEST_TRAMVAI_VERSION = '1.115.6';
 const LATEST_LIB_VERSION = '0.8.23';
 const PRERELEASE_LIB_VERSION = '2.0.1';
+const CURRENT_TRAMVAI_VERSION = '1.93.2';
+
+const packageJsonPath = resolve('package.json');
 
 let mockPackageJson: Record<string, any>;
 const mockFsWrite = jest.fn();
@@ -38,13 +42,13 @@ beforeEach(() => {
 it('should update tramvai deps to latest versions', async () => {
   mockPackageJson = {
     dependencies: {
-      '@tramvai/core': '1.93.2',
-      '@tramvai/module-common': '1.93.2',
+      '@tramvai/core': CURRENT_TRAMVAI_VERSION,
+      '@tramvai/module-common': CURRENT_TRAMVAI_VERSION,
       '@tinkoff/router': '^0.2.3',
       '@tinkoff/url': '0.3.2',
     },
     devDependencies: {
-      '@tramvai/cli': '1.93.2',
+      '@tramvai/cli': CURRENT_TRAMVAI_VERSION,
     },
     peerDependencies: {
       '@tinkoff/dippy': '0.7.10',
@@ -72,11 +76,12 @@ it('should update tramvai deps to latest versions', async () => {
     return {};
   });
 
-  await updatePackageJson(LATEST_TRAMVAI_VERSION);
+  await updatePackageJson(LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION);
 
+  // eslint-disable-next-line jest/no-interpolation-in-snapshots
   expect(mockFsWrite.mock.calls[0]).toMatchInlineSnapshot(`
     [
-      "package.json",
+      "${packageJsonPath}",
       "{
       "dependencies": {
         "@tramvai/core": "1.115.6",
@@ -98,14 +103,14 @@ it('should update tramvai deps to latest versions', async () => {
 it('prerelease should be used for dependant libs', async () => {
   mockPackageJson = {
     dependencies: {
-      '@tramvai/core': '1.93.2',
-      '@tramvai/module-common': '1.93.2',
+      '@tramvai/core': CURRENT_TRAMVAI_VERSION,
+      '@tramvai/module-common': CURRENT_TRAMVAI_VERSION,
       '@tinkoff/router': '^0.2.3',
       '@tinkoff/url': '0.3.2',
       '@tinkoff/pack-polyfills': '1.0.0',
     },
     devDependencies: {
-      '@tramvai/cli': '1.93.2',
+      '@tramvai/cli': CURRENT_TRAMVAI_VERSION,
     },
     peerDependencies: {
       '@tinkoff/dippy': '0.7.10',
@@ -133,11 +138,12 @@ it('prerelease should be used for dependant libs', async () => {
     return {};
   });
 
-  await updatePackageJson(LATEST_TRAMVAI_VERSION, true);
+  await updatePackageJson(LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION, true);
 
+  // eslint-disable-next-line jest/no-interpolation-in-snapshots
   expect(mockFsWrite.mock.calls[0]).toMatchInlineSnapshot(`
     [
-      "package.json",
+      "${packageJsonPath}",
       "{
       "dependencies": {
         "@tramvai/core": "1.115.6",

package/src/commands/update/updatePackageJson.ts

@@ -3,6 +3,7 @@ import fs from 'fs';
 import pMap from 'p-map';
 import type { Ora } from 'ora';
 import ora from 'ora';
+import { resolve } from 'path';
 import { packageHasVersion } from '../../utils/commands/dependencies/packageHasVersion';
 import { getLibPackageVersion } from './dependantLibs';
 import { isDependantLib, isUnifiedVersion } from '../../utils/tramvaiVersions';
@@ -61,21 +62,15 @@ const updateDependencies = (
   );
 };
 
-export const updatePackageJson = async (version: string, prerelease?: boolean) => {
-  const file = fs.readFileSync('package.json');
+export const updatePackageJson = async (
+  version: string,
+  currentVersion: string,
+  prerelease?: boolean,
+  path = '.'
+) => {
+  const packageJsonPath = resolve(path, 'package.json');
+  const file = fs.readFileSync(packageJsonPath);
   const content = JSON.parse(file.toString());
-  const currentVersion = getVersionFromDep(content.dependencies['@tramvai/core']);
-
-  if (!currentVersion) {
-    throw new Error(
-      "Couldn't resolve current tramvai version, do you have '@tramvai/core' package in your dependencies?"
-    );
-  }
-
-  if (currentVersion === version) {
-    console.error('The installed version is equal to the current version, no update is required.');
-    return;
-  }
 
   const spinner = ora(`Updating package.json versions`).start();
 
@@ -90,7 +85,7 @@ export const updatePackageJson = async (version: string, prerelease?: boolean) =
       spinner
     );
 
-    fs.writeFileSync('package.json', JSON.stringify(content, null, 2));
+    fs.writeFileSync(packageJsonPath, JSON.stringify(content, null, 2));
   } finally {
     spinner.stop();
   }

package/src/config/configManager.ts

@@ -25,7 +25,7 @@ export interface Settings<E extends Env> {
   rootDir?: string;
   version?: string;
   buildType?: BuildType;
-  debug?: boolean;
+  debug?: string | boolean;
   verboseWebpack?: boolean;
   trace?: boolean;
   sourceMap?: boolean;

package/src/config/constants.ts

@@ -1,5 +1,3 @@
 export const extensions = ['.mjs', '.js', '.jsx', '.ts', '.tsx'];
 
-export const DEBUG_ARGV = ['--inspect', '-r', 'source-map-support/register'];
-
 export const TRACE_ARGV = ['--trace-warnings', '--trace-uncaught'];

package/src/config/utils.ts

@@ -0,0 +1,18 @@
+export function getDebugArg(debugEnv: boolean | string | undefined) {
+  if (!debugEnv) {
+    return [];
+  }
+
+  const sourceMapsArg = ['-r', 'source-map-support/register'];
+  const baseDebugArgs = ['--inspect', ...sourceMapsArg];
+
+  if (debugEnv === 'wait') {
+    return ['--inspect-wait', ...sourceMapsArg];
+  }
+
+  if (debugEnv === 'break') {
+    return ['--inspect-brk', ...sourceMapsArg];
+  }
+
+  return baseDebugArgs;
+}

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

@@ -33,6 +33,9 @@ beforeAll(async () => {
     strictErrorHandle: true,
     config: {
       name: 'swc-app',
+      webpack: {
+        devtool: 'eval',
+      },
       type: 'application',
       root: './',
       experiments: {

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

@@ -45,7 +45,7 @@ export const webpackClientConfig = ({
 
   config.mode('development');
 
-  config.devtool(configManager.webpack.devtool ?? 'eval');
+  config.devtool(configManager.webpack.devtool ?? false);
 
   if (configManager.sourceMap) {
     config.batch(sourcemaps(configManager));