@tramvai/cli 5.50.0 → 5.53.78

package/src/commands/build/command.ts

@@ -7,6 +7,7 @@ import type { BuildCommand as BuildCommandType } from '../../api/build';
 import { checkPwaDependencies } from '../../validators/commands/checkPwaDependencies';
 import { checkSwcDependencies } from '../../validators/commands/checkSwcDependencies';
 import { checkReactCompilerDependencies } from '../../validators/commands/checkReactCompilerDependencies';
+import { getFeaturesProperties, getProjectProperties } from '../../models/analytics/utils';
 
 export type Params = Parameters<BuildCommandType>[0] & {
   target: string;
@@ -59,17 +60,6 @@ class BuildCommand extends CLICommand<Params> {
       transformer: (value: string) => value !== 'false',
       description: 'Enable/disable persistent file cache for used cli builder',
     },
-    {
-      name: '--modern',
-      value: '[modern]',
-      description: 'modern compilation code with es2015+',
-    },
-    {
-      name: '--onlyModern',
-      value: '[onlyModern]',
-      transformer: (value: string) => value !== 'false',
-      description: 'Emit only modern build from client compilation',
-    },
     {
       name: '--verboseWebpack',
       value: '[verboseWebpack]',
@@ -89,9 +79,51 @@ class BuildCommand extends CLICommand<Params> {
     checkReactCompilerDependencies,
   ];
 
-  action(parameters: Params) {
+  async action(parameters: Params) {
+    const start = Date.now();
+
+    await this.context.analytics.send({
+      event: 'cli:command:start',
+      message: '@tramvai/cli production build started',
+      level: 'INFO',
+      command: 'build',
+      parameters,
+      project: getProjectProperties({ parameters, configManager: this.context.config }),
+      features: getFeaturesProperties({ parameters, configManager: this.context.config }),
+    });
+
     // used require for lazy code execution
-    return require('./build').default(this.context, parameters);
+    return require('./build')
+      .default(this.context, parameters)
+      .then(async (result) => {
+        await this.context.analytics.send({
+          event: 'cli:command:end',
+          message: '@tramvai/cli production build finished',
+          level: 'INFO',
+          command: 'build',
+          parameters,
+          duration: Date.now() - start,
+          project: getProjectProperties({ parameters, configManager: this.context.config }),
+          memoryUsage: this.context.analytics.memoryMonitor.read(),
+        });
+
+        return result;
+      })
+      .catch(async (error) => {
+        await this.context.analytics.send({
+          event: 'cli:command:error',
+          message: '@tramvai/cli production build failed',
+          level: 'ERROR',
+          command: 'build',
+          parameters,
+          duration: Date.now() - start,
+          error,
+          project: getProjectProperties({ parameters, configManager: this.context.config }),
+          memoryUsage: this.context.analytics.memoryMonitor.read(),
+        });
+
+        throw error;
+      });
   }
 }
 

package/src/commands/createApp.ts

@@ -2,7 +2,6 @@ import type { Provider } from '@tinkoff/dippy';
 import { createChildContainer } from '@tinkoff/dippy';
 import { initRootContainer } from '../di/root';
 import {
-  analyticsProviders,
   builderProviders,
   commandsProviders,
   configProviders,
@@ -20,7 +19,6 @@ export const createApp = ({
   providers: Provider[];
 }): typeof COMMAND_RUNNER_TOKEN => {
   const rootContainer = initRootContainer([
-    ...analyticsProviders,
     ...stdProviders,
     ...configProviders,
     ...commandsProviders,

package/src/commands/new/new.ts

@@ -1,5 +1,6 @@
 import path from 'path';
 import chalk from 'chalk';
+import { command } from 'execa';
 import inquirer from 'inquirer';
 import { packageManagerFactory } from '@tinkoff/package-manager-wrapper';
 import type { Context } from '../../models/context';
@@ -21,7 +22,22 @@ import { typeQuestion } from './questions/type';
 // ts не копирует файлы, так что шаблона не будет в lib директории =(
 const getPathToTemplate = (type: Type, template: Templates) =>
   path.resolve(__dirname, '../../../src/commands/new/templates', type, template);
-const getPathToShared = () => path.resolve(__dirname, '../../../src/commands/new/templates/shared');
+const getPathToPackageManagerConfig = (packageManager: PackageManagers) => {
+  if (packageManager === 'yarn') {
+    return path.resolve(
+      __dirname,
+      '../../../src/commands/new/templates/packageManagerConfig/yarnPackageManagerConfig'
+    );
+  }
+
+  return path.resolve(
+    __dirname,
+    '../../../src/commands/new/templates/packageManagerConfig/defaultPackageManagerConfig'
+  );
+};
+const getPathToShared = () => {
+  return path.resolve(__dirname, '../../../src/commands/new/templates/shared');
+};
 const getPathToBlock = (type: Type) =>
   path.resolve(__dirname, '../../../src/commands/new/templates', type, 'block');
 const getPathToMonorepoBlock = () =>
@@ -29,6 +45,7 @@ const getPathToMonorepoBlock = () =>
 const getPathToTestingFramework = (type: Type, testingFramework: TestingFrameworks) =>
   path.resolve(__dirname, '../../../src/commands/new/templates', type, 'testing', testingFramework);
 
+// eslint-disable-next-line max-statements
 export default async function createNew(context: Context, params: Params): Promise<CommandResult> {
   const {
     name: inputName,
@@ -64,24 +81,31 @@ export default async function createNew(context: Context, params: Params): Promi
 
   const templateDir = getPathToTemplate(type, template);
   const sharedDir = getPathToShared();
+  const packageManagerConfigDif = getPathToPackageManagerConfig(packageManager);
   const blockDir = getPathToBlock(type);
   const isMonorepo = template === 'monorepo';
+
+  const isYarn = packageManager === 'yarn';
+
   const baseDir = type === 'app' ? 'apps' : 'child-apps';
+  const rootDir = path.resolve(process.cwd(), directoryName);
   const blockDirectoryName = {
     monorepo: path.join(baseDir, name),
     multirepo: 'src',
   }[template];
 
   const templateData = {
+    isMonorepo,
     configEntry,
     isJest: testingFramework === 'jest',
     isNpm: packageManager === 'npm',
-    isYarn: packageManager === 'yarn',
+    isYarn,
     workspaceBaseDir: isMonorepo ? baseDir : undefined,
   };
 
   await renderTemplate(templateDir, directoryName, templateData);
   await renderTemplate(sharedDir, directoryName, templateData);
+  await renderTemplate(packageManagerConfigDif, directoryName, templateData);
   await renderTemplate(blockDir, path.join(directoryName, blockDirectoryName), templateData);
   if (template === 'monorepo') {
     const monorepoBlockDir = getPathToMonorepoBlock();
@@ -100,15 +124,23 @@ export default async function createNew(context: Context, params: Params): Promi
       templateData
     );
   }
-
   await initializationGit(directoryName);
+
+  if (isYarn) {
+    await command('yarn set version berry', {
+      env: {
+        YARN_HTTP_PROXY: process.env.HTTP_PROXY,
+        YARN_HTTPS_PROXY: process.env.HTTPS_PROXY,
+      },
+      cwd: rootDir,
+      stdio: 'inherit',
+    });
+  }
+
   await installDependencies({
     localDir: directoryName,
     type,
-    packageManager: packageManagerFactory(
-      { rootDir: path.resolve(process.cwd(), directoryName) },
-      packageManager
-    ),
+    packageManager: packageManagerFactory({ rootDir }, packageManager),
     testingFramework,
     workspace: isMonorepo ? blockDirectoryName : undefined,
   });

package/src/commands/new/templates/packageManagerConfig/yarnPackageManagerConfig/_yarnrc.yml.hbs

@@ -0,0 +1,9 @@
+npmRegistryServer: "https://registry.npmjs.org/"
+enableStrictSsl: false
+
+nodeLinker: node-modules
+cacheFolder: .yarn-cache
+
+enableGlobalCache: false
+
+tsEnableAutoTypes: false

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

@@ -8,6 +8,16 @@ yarn-error.log*
 # Dependency directories
 node_modules/
 
+.yarn-cache
+.yarn/*
+**/.yarn/*
+!.yarn/releases
+!.yarn/patches
+!.yarn/plugins
+!.yarn/sdks
+!.yarn/versions
+
+
 # IDE
 .DS_Store
 .vscode

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

@@ -1,5 +1,9 @@
 {
-  "name": "{{configEntry.name}}",
+  {{#if isMonorepo}}
+    "name": "{{configEntry.name}}-monorepo",
+  {{else}}
+    "name": "{{configEntry.name}}",
+  {{/if}}
   "private": true,
   "scripts": {
     "start": "tramvai start {{configEntry.name}}",

package/src/commands/start/command.ts

@@ -7,6 +7,7 @@ import type { StartCommand as StartCommandType } from '../../api/start';
 import { checkPwaDependencies } from '../../validators/commands/checkPwaDependencies';
 import { checkSwcDependencies } from '../../validators/commands/checkSwcDependencies';
 import { checkReactCompilerDependencies } from '../../validators/commands/checkReactCompilerDependencies';
+import { getFeaturesProperties, getProjectProperties } from '../../models/analytics/utils';
 
 export type Params = Parameters<StartCommandType>[0] & {
   target: string;
@@ -61,11 +62,6 @@ export class StartCommand extends CLICommand<Params> {
       value: '[profile]',
       description: 'report statistic how much time execute loaders and plugins',
     },
-    {
-      name: '--modern',
-      value: '[modern]',
-      description: 'modern compilation code with es2015+',
-    },
     {
       name: '--sm, --sourceMap',
       value: '[sourceMap]',
@@ -142,8 +138,47 @@ export class StartCommand extends CLICommand<Params> {
     checkReactCompilerDependencies,
   ];
 
-  action(parameters) {
+  async action(parameters) {
+    const start = Date.now();
+
+    await this.context.analytics.send({
+      event: 'cli:command:start',
+      message: '@tramvai/cli development build started',
+      level: 'INFO',
+      command: 'start',
+      parameters,
+      project: getProjectProperties({ parameters, configManager: this.context.config }),
+      features: getFeaturesProperties({ parameters, configManager: this.context.config }),
+    });
+
     // used require for lazy code execution
-    return require('./start').default(this.context, parameters);
+    return require('./start')
+      .default(this.context, parameters, async () => {
+        await this.context.analytics.send({
+          event: 'cli:command:end',
+          message: '@tramvai/cli development build finished',
+          level: 'INFO',
+          command: 'start',
+          parameters,
+          duration: Date.now() - start,
+          project: getProjectProperties({ parameters, configManager: this.context.config }),
+          memoryUsage: this.context.analytics.memoryMonitor.read(),
+        });
+      })
+      .catch(async (error) => {
+        await this.context.analytics.send({
+          event: 'cli:command:error',
+          message: '@tramvai/cli development build failed',
+          level: 'ERROR',
+          command: 'start',
+          parameters,
+          duration: Date.now() - start,
+          error,
+          project: getProjectProperties({ parameters, configManager: this.context.config }),
+          memoryUsage: this.context.analytics.memoryMonitor.read(),
+        });
+
+        throw error;
+      });
   }
 }

package/src/commands/start/start.ts

@@ -3,13 +3,19 @@ import type { CommandResult } from '../../models/command';
 
 import { app } from '../index';
 
-export default async (context: Context, parameters): Promise<CommandResult | any> => {
+export default async (
+  context: Context,
+  parameters,
+  finishedBuildCallback: Function
+): Promise<CommandResult | any> => {
   const { staticServer } = await app.run('start', {
     ...parameters,
     // игнорируем ошибку т.к. сборка не обязательно правильная при запуске, но при виде ошибки разработчик сможет поправить и не понадобится перезапускать с нуля
     strictErrorHandle: false,
   });
 
+  await finishedBuildCallback();
+
   await new Promise((resolve) => {
     staticServer.on('close', resolve);
   });

package/src/commands/static/application.ts

@@ -37,7 +37,6 @@ export const staticApp = async (
     env: 'production',
     ...options,
     buildType: 'client',
-    modern: false,
     port: portManager.port,
     staticPort: portManager.staticPort,
   });

package/src/commands/update/command.ts

@@ -10,7 +10,15 @@ class UpdateCommand extends CLICommand {
 
   command = `update [to]`;
 
-  options = [];
+  options = [
+    {
+      name: '-t, --tag',
+      value: '[tag]',
+      transformer: (value: string) => value !== 'false',
+      description:
+        'Install target version as is - useful for dist tags like prerelease / stable-v5.x.x/ custom tags',
+    },
+  ];
 
   alias = 'u';
 

package/src/commands/update/dependantLibs.ts

@@ -1,25 +1,40 @@
 import getLatestPackageVersion from 'latest-version';
 import getPackageInfo from 'package-json';
+import type { Ora } from 'ora';
 import { DEPENDANT_LIBS_MAP } from '../../utils/tramvaiVersions';
 
 export const getLibPackageVersion = async (
   name: string,
-  unifiedVersion: string,
-  prerelease: boolean
+  version: string,
+  resolvedVersion: string,
+  spinner: Ora
 ): Promise<string | undefined> => {
   const unifiedModule = DEPENDANT_LIBS_MAP.get(name);
 
   if (!unifiedModule) {
-    return getLatestPackageVersion(name, { version: prerelease ? 'prerelease' : 'latest' });
+    try {
+      return await getLatestPackageVersion(name, { version });
+    } catch (e) {
+      // clear the spinner to be able to log info that should be preserved in the output
+      // the idea borrowed from [here](https://github.com/sindresorhus/ora/issues/120)
+      spinner.clear();
+
+      console.warn(`⚠️ cannot resolve proper version for the "${name}" package,
+You have to update this package by yourself.`);
+
+      return;
+    }
   }
 
-  const { dependencies } = await getPackageInfo(unifiedModule, { version: unifiedVersion });
+  const { dependencies } = await getPackageInfo(unifiedModule, { version: resolvedVersion });
 
   if (!dependencies[name]) {
-    console.warn(
-      `⚠️ cannot resolve proper version for the "${name}" package.
-You have to update this package by yourself.`
-    );
+    // clear the spinner to be able to log info that should be preserved in the output
+    // the idea borrowed from [here](https://github.com/sindresorhus/ora/issues/120)
+    spinner.clear();
+
+    console.warn(`⚠️ cannot resolve proper version for the "${name}" package,
+You have to update this package by yourself.`);
 
     return;
   }

package/src/commands/update/update.ts

@@ -9,13 +9,14 @@ import { findTramvaiVersion } from '../../utils/commands/dependencies/findTramva
 
 export type Params = {
   to: string;
+  tag?: boolean;
 };
 
 export default async (
   context: Context,
-  { to: version = 'latest' }: Params
+  { to: version = 'latest', tag }: Params
 ): Promise<CommandResult> => {
-  const targetVersion = await getLatestPackageVersion('@tramvai/cli', version);
+  const resolvedVersion = tag ? version : await getLatestPackageVersion('@tramvai/cli', version);
   const currentVersion = await findTramvaiVersion();
 
   if (!currentVersion) {
@@ -24,7 +25,7 @@ export default async (
     );
   }
 
-  if (currentVersion === version) {
+  if (currentVersion === version || currentVersion === resolvedVersion) {
     throw new Error(
       'The installed version is equal to the current version, no update is required.'
     );
@@ -33,18 +34,18 @@ export default async (
   context.logger.event({
     type: 'info',
     event: 'resolving-version',
-    message: `Tramvai version resolved to ${targetVersion}`,
+    message: `Next tramvai version resolved to ${tag ? 'tag' : 'version'} "${resolvedVersion}", current version is "${currentVersion}"`,
   });
 
   if (context.packageManager.workspaces) {
     await Promise.all(
       context.packageManager.workspaces.map((directory) =>
-        updatePackageJson(targetVersion, currentVersion, version === 'prerelease', directory)
+        updatePackageJson(version, resolvedVersion, currentVersion, tag, directory)
       )
     );
   }
 
-  await updatePackageJson(targetVersion, currentVersion, version === 'prerelease');
+  await updatePackageJson(version, resolvedVersion, currentVersion, tag);
 
   context.logger.event({
     type: 'info',

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

@@ -76,7 +76,7 @@ it('should update tramvai deps to latest versions', async () => {
     return {};
   });
 
-  await updatePackageJson(LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION);
+  await updatePackageJson(LATEST_TRAMVAI_VERSION, LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION);
 
   // eslint-disable-next-line jest/no-interpolation-in-snapshots
   expect(mockFsWrite.mock.calls[0]).toMatchInlineSnapshot(`
@@ -100,7 +100,7 @@ it('should update tramvai deps to latest versions', async () => {
   `);
 });
 
-it('prerelease should be used for dependant libs', async () => {
+it('prerelease should be resolved and used for dependant libs', async () => {
   mockPackageJson = {
     dependencies: {
       '@tramvai/core': CURRENT_TRAMVAI_VERSION,
@@ -138,7 +138,7 @@ it('prerelease should be used for dependant libs', async () => {
     return {};
   });
 
-  await updatePackageJson(LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION, true);
+  await updatePackageJson('prerelease', LATEST_TRAMVAI_VERSION, CURRENT_TRAMVAI_VERSION);
 
   // eslint-disable-next-line jest/no-interpolation-in-snapshots
   expect(mockFsWrite.mock.calls[0]).toMatchInlineSnapshot(`
@@ -162,3 +162,66 @@ it('prerelease should be used for dependant libs', async () => {
     ]
   `);
 });
+
+it('dist tag should be used for dependant libs', async () => {
+  mockPackageJson = {
+    dependencies: {
+      '@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': CURRENT_TRAMVAI_VERSION,
+    },
+    peerDependencies: {
+      '@tinkoff/dippy': '0.7.10',
+    },
+  };
+
+  mockPackageInfoDependencies.mockImplementation((dep: string) => {
+    switch (dep) {
+      case '@tramvai/core':
+        return { '@tinkoff/dippy': '0.7.44', '@tinkoff/utils': '^2.1.0' };
+      case '@tramvai/module-common':
+        return {
+          '@tinkoff/error': '0.6.1',
+          '@tinkoff/url': '0.4.1',
+        };
+      case '@tramvai/cli':
+        return {};
+      case '@tramvai/module-router':
+        return {
+          '@tinkoff/router': '0.4.3',
+          '@tinkoff/url': '0.4.1',
+        };
+    }
+
+    return {};
+  });
+
+  await updatePackageJson('prerelease', 'prerelease', CURRENT_TRAMVAI_VERSION, true);
+
+  // eslint-disable-next-line jest/no-interpolation-in-snapshots
+  expect(mockFsWrite.mock.calls[0]).toMatchInlineSnapshot(`
+    [
+      "${packageJsonPath}",
+      "{
+      "dependencies": {
+        "@tramvai/core": "prerelease",
+        "@tramvai/module-common": "prerelease",
+        "@tinkoff/router": "prerelease",
+        "@tinkoff/url": "prerelease",
+        "@tinkoff/pack-polyfills": "prerelease"
+      },
+      "devDependencies": {
+        "@tramvai/cli": "prerelease"
+      },
+      "peerDependencies": {
+        "@tinkoff/dippy": "prerelease"
+      }
+    }",
+    ]
+  `);
+});

package/src/commands/update/updatePackageJson.ts

@@ -1,4 +1,3 @@
-import { parse, minVersion } from 'semver';
 import fs from 'fs';
 import pMap from 'p-map';
 import type { Ora } from 'ora';
@@ -8,17 +7,12 @@ import { packageHasVersion } from '../../utils/commands/dependencies/packageHasV
 import { getLibPackageVersion } from './dependantLibs';
 import { isDependantLib, isUnifiedVersion } from '../../utils/tramvaiVersions';
 
-const getVersionFromDep = (dep?: string) => {
-  if (dep) {
-    return parse(dep)?.version || minVersion(dep)?.version;
-  }
-};
-
 const updateDependencies = (
   dependencies: Record<string, string> = {},
-  targetVersion: string,
-  prerelease: boolean,
+  version: string,
+  resolvedVersion: string,
   currentVersion: string,
+  tag: boolean,
   spinner: Ora
 ) => {
   return pMap<string, void>(
@@ -26,10 +20,12 @@ const updateDependencies = (
     async (dep) => {
       let nextVersion: string | undefined;
 
-      if (isUnifiedVersion(dep) && getVersionFromDep(dependencies[dep]) === currentVersion) {
-        nextVersion = targetVersion;
+      if (isUnifiedVersion(dep) && dependencies[dep] === currentVersion) {
+        nextVersion = resolvedVersion;
       } else if (isDependantLib(dep)) {
-        const libVersion = await getLibPackageVersion(dep, targetVersion, prerelease);
+        const libVersion = tag
+          ? resolvedVersion
+          : await getLibPackageVersion(dep, version, resolvedVersion, spinner);
         nextVersion = libVersion;
       }
 
@@ -64,8 +60,9 @@ const updateDependencies = (
 
 export const updatePackageJson = async (
   version: string,
+  resolvedVersion: string,
   currentVersion: string,
-  prerelease?: boolean,
+  tag?: boolean,
   path = '.'
 ) => {
   const packageJsonPath = resolve(path, 'package.json');
@@ -75,13 +72,28 @@ export const updatePackageJson = async (
   const spinner = ora(`Updating package.json versions`).start();
 
   try {
-    await updateDependencies(content.dependencies, version, prerelease, currentVersion, spinner);
-    await updateDependencies(content.devDependencies, version, prerelease, currentVersion, spinner);
+    await updateDependencies(
+      content.dependencies,
+      version,
+      resolvedVersion,
+      currentVersion,
+      tag,
+      spinner
+    );
+    await updateDependencies(
+      content.devDependencies,
+      version,
+      resolvedVersion,
+      currentVersion,
+      tag,
+      spinner
+    );
     await updateDependencies(
       content.peerDependencies,
       version,
-      prerelease,
+      resolvedVersion,
       currentVersion,
+      tag,
       spinner
     );