@servicetitan/startup 33.1.0 → 34.0.0

package/src/cli/commands/upload-sourcemaps.ts

@@ -1,20 +1,26 @@
 import { isCI } from '@servicetitan/install';
-import path from 'path';
 import { execSync } from 'child_process';
+import path from 'path';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { TSConfig } from '../utils';
-import { Command, CommandArgs } from './types';
-
-interface Args extends CommandArgs {
-    dry?: boolean;
-    releaseVersion: string;
-}
+import { Command, CommandOptions } from './types';
+
+const options = {
+    dry: { boolean: true, description: 'Dry run mode' },
+    releaseVersion: {
+        string: true,
+        demandOption: true,
+        requiresArg: true,
+        description: 'Release version',
+    },
+} satisfies CommandOptions;
 
 interface PackageJson {
     name: string;
 }
 
-export class UploadSourcemaps extends Command<Args> {
+export class UploadSourcemaps extends Command<typeof options> {
+    static readonly options = options;
     #outDir?: string;
     #packageJson?: PackageJson;
 
@@ -41,10 +47,6 @@ export class UploadSourcemaps extends Command<Args> {
             return false;
         }
 
-        if (!this.args.releaseVersion) {
-            throw new Error('--release-version is required');
-        }
-
         return true;
     }
 

package/src/cli/commands/utils.ts

@@ -0,0 +1,6 @@
+export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
+export const ROLLBACK_TAG_SUFFIX = '-rollback-1';
+
+export function buildRollbackTag(tag: string): string {
+    return `${tag}${ROLLBACK_TAG_SUFFIX}`;
+}

package/src/cli/index.ts

@@ -1,14 +1,17 @@
 import chalk from 'chalk';
 import execa from 'execa';
+import kebabCase from 'lodash.kebabcase';
 import path from 'path';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { CommandName, getStartupVersion, log } from '../utils';
 import { Command, getCommand } from './commands';
-import { setNodeOptions } from './utils';
+import { checkStartupLocation, setNodeOptions } from './utils';
+
+const yargsInstance = yargs(hideBin(process.argv));
 
 Object.values(CommandName)
-    .reduce((y, name) => addCommand(name, y), yargs(hideBin(process.argv)))
+    .reduce((y, name) => addCommand(name, y), yargsInstance)
     .usage('Usage: startup <command> [options]')
     .epilogue(
         chalk.bold.cyan(`startup cli v${getStartupVersion()}\n`) +
@@ -24,7 +27,7 @@ Object.values(CommandName)
         } as any,
     })
     .version()
-    .wrap(Math.min(100, yargs.terminalWidth()))
+    .wrap(Math.min(100, yargsInstance.terminalWidth()))
     .help()
     .parse();
 
@@ -35,7 +38,7 @@ function addCommand(name: CommandName, y: typeof yargs) {
     const nameWithArgs = name + (_?.description ? ` ${_.description}` : '');
     const groupedOptions = Object.entries(options).reduce(
         (result, [key, value]) => {
-            result[key] = { group: 'Command Options:', ...value };
+            result[kebabCase(key)] = { group: 'Command Options:', ...value };
             return result;
         },
         {} as NonNullable<typeof klass.options>
@@ -51,11 +54,12 @@ function addCommand(name: CommandName, y: typeof yargs) {
 
 function handleCommand(name: CommandName, argv: any) {
     const Command = getCommand(name)!;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const command = new Command({ ...argv, _: argv._.slice(1) });
 
     checkNodeVersion();
+    checkStartupLocation(name, command);
 
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const command = new Command({ ...argv, _: argv._.slice(1) });
     if (setNodeOptions(name, command)) {
         log.debug('run', `Running ${name} in child process with amended NODE_OPTIONS`);
         execa(process.argv[0], process.argv.slice(1), { stdio: 'inherit' }).catch(reason => {
@@ -79,5 +83,5 @@ function checkNodeVersion() {
         `error: node v${nodeVersion} detected, only even-numbered LTS versions ${engines.node} are supported`
     );
     log.text('See https://nodejs.org/en/download for LTS versions');
-    process.exit(127);
+    process.exit(1);
 }

package/src/cli/tasks/__tests__/cli-task.test.ts

@@ -1,6 +1,6 @@
 import { log } from '../../../utils';
-import { CliTask, Indicators } from '../cli-task';
 import { pipeStdout, watchStdout } from '../../utils';
+import { CliTask, Indicators } from '../cli-task';
 
 jest.mock('execa', () =>
     jest.fn().mockReturnValue(

package/src/cli/tasks/__tests__/swc-compile-package.test.ts

@@ -1,6 +1,6 @@
 import { swcDir } from '@swc/cli';
-import deepmerge from 'deepmerge';
 import debounce from 'debounce';
+import deepmerge from 'deepmerge';
 import { fs, vol } from 'memfs';
 import { getSwcCompilePackageConfiguration, log } from '../../../utils';
 import { SwcCompilePackage } from '../swc-compile-package';
@@ -10,6 +10,8 @@ jest.mock('fs', () => fs);
 jest.mock('@swc/cli', () => ({
     swcDir: jest.fn(),
 }));
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),

package/src/cli/tasks/__tests__/tsc-compile-package.test.ts

@@ -10,6 +10,8 @@ jest.mock('execa', () =>
         })
     )
 );
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 const tsConfig = 'tsconfig.build.json';
 

package/src/cli/tasks/__tests__/tsc-compile.test.ts

@@ -14,6 +14,8 @@ jest.mock('execa', () =>
         })
     )
 );
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 describe(`[startup] ${TscCompile.name} task`, () => {
     let options: ConstructorParameters<typeof TscCompile>[0];
@@ -57,12 +59,10 @@ describe(`[startup] ${TscCompile.name} task`, () => {
         caption: string,
         {
             watch = false,
-            typeCheckOnly = false,
             tsConfigs,
             stdio,
         }: {
             watch?: boolean;
-            typeCheckOnly?: boolean;
             tsConfigs: string[];
             stdio: string | string[];
         }
@@ -78,7 +78,7 @@ describe(`[startup] ${TscCompile.name} task`, () => {
                         watch ? '-w' : undefined,
                         '--pretty',
                         '--preserveWatchOutput',
-                        typeCheckOnly ? '--emitDeclarationOnly' : undefined,
+                        '--emitDeclarationOnly',
                         ...tsConfigs.map(config => expect.stringContaining(path.normalize(config))),
                     ].filter(item => item !== undefined)
                 ),
@@ -106,16 +106,6 @@ describe(`[startup] ${TscCompile.name} task`, () => {
         });
     });
 
-    describe('with "typeCheckOnly" mode', () => {
-        beforeEach(() => (options = { typeCheckOnly: true }));
-
-        itRunsTsc('in "typeCheckOnly" mode', {
-            typeCheckOnly: true,
-            tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
-            stdio: 'inherit',
-        });
-    });
-
     describe('with "scope"', () => {
         beforeEach(() => (options = { scope: ['foo'] }));
 

package/src/cli/tasks/cli-task.ts

@@ -1,6 +1,6 @@
 import execa from 'execa';
-import { Task, TaskParameters } from './task';
 import { pipeStdout, watchStdout } from '../utils';
+import { Task, TaskParameters } from './task';
 
 export interface Indicators {
     end: string;

package/src/cli/tasks/swc-compile-package.ts

@@ -1,13 +1,11 @@
 import { Options, swcDir } from '@swc/cli';
 import debounce from 'debounce';
 import deepmerge from 'deepmerge';
-
 import { getFolders, getSwcCompilePackageConfiguration, getTsConfig, log } from '../../utils';
-import { CommandArgs } from '../commands';
 import { TSConfig } from '../utils';
 import { Task } from './task';
 
-interface Args extends CommandArgs {
+interface Args {
     watch?: boolean;
 }
 

package/src/cli/tasks/tsc-compile-package.ts

@@ -1,8 +1,7 @@
 import { getTsConfig } from '../../utils';
-import { CommandArgs } from '../commands';
 import { CliTask } from './cli-task';
 
-interface Args extends CommandArgs {
+interface Args {
     watch?: boolean;
 }
 

package/src/cli/tasks/tsc-compile.ts

@@ -1,8 +1,7 @@
 import { getPackages, getPackagesGraph, getTsConfig, log, Package, PackageType } from '../../utils';
-import { CommandArgs } from '../commands';
 import { CliTask } from './cli-task';
 
-interface Args extends CommandArgs {
+interface Args {
     ignore?: string | string[];
     scope?: string | string[];
     watch?: boolean;

package/src/cli/utils/__tests__/bundle.test.ts

@@ -3,6 +3,7 @@ import path from 'path';
 import { getPortPromise } from 'portfinder';
 import webpack from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
+import { createPackage } from '../../../__mocks__';
 import {
     getConfiguration,
     getFolders,
@@ -12,8 +13,6 @@ import {
     loadSharedDependencies,
 } from '../../../utils';
 import { createWebpackConfig } from '../../../webpack';
-import { createPackage } from '../../../__mocks__';
-
 import { bundle, webpackDevConfigFileName, webpackProdConfigFileName } from '../bundle';
 
 jest.mock('fs', () => fs);

package/src/cli/utils/__tests__/check-args.test.ts

@@ -1,5 +1,5 @@
-import { checkArgs } from '../check-args';
 import { log } from '../../../utils';
+import { checkArgs } from '../check-args';
 
 jest.mock('../../../utils', () => ({ log: { warning: jest.fn() } }));
 

package/src/cli/utils/__tests__/check-startup-location.test.ts

@@ -0,0 +1,88 @@
+import { log } from '../../../utils';
+import { Command } from '../../commands/types';
+import { checkStartupLocation } from '../check-startup-location';
+import { npmGetProjectRoot } from '../cli-npm';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { error: jest.fn() },
+}));
+jest.mock('../cli-npm');
+
+class TestCommand extends Command {
+    async execute() {
+        // no-op
+    }
+}
+
+describe('[startup] Cli Utils', () => {
+    describe(checkStartupLocation.name, () => {
+        const originalSkipLocationCheck = process.env.SKIP_STARTUP_LOCATION_CHECK;
+        const commandName: any = 'test';
+        let mockCommand: Command;
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.mocked(npmGetProjectRoot).mockReturnValue(process.cwd());
+            jest.spyOn(process, 'exit').mockImplementation(jest.fn() as any);
+            delete process.env.SKIP_STARTUP_LOCATION_CHECK;
+            mockCommand = new TestCommand({});
+        });
+
+        afterAll(() => {
+            if (originalSkipLocationCheck !== undefined) {
+                process.env.SKIP_STARTUP_LOCATION_CHECK = originalSkipLocationCheck;
+            }
+        });
+
+        const subject = () => checkStartupLocation(commandName, mockCommand);
+
+        function itDoesNothing() {
+            test('does nothing', () => {
+                subject();
+
+                expect(log.error).not.toHaveBeenCalled();
+                expect(process.exit).not.toHaveBeenCalled();
+            });
+        }
+
+        itDoesNothing();
+
+        test('sets process.env.SKIP_STARTUP_LOCATION_CHECK', () => {
+            subject();
+
+            expect(process.env.SKIP_STARTUP_LOCATION_CHECK).toBeDefined();
+        });
+
+        describe('when running from non-project directory', () => {
+            beforeEach(() => jest.mocked(npmGetProjectRoot).mockReturnValue('foo'));
+
+            test('logs error and exits process with error code', () => {
+                subject();
+
+                expect(log.error).toHaveBeenCalledWith(
+                    `Error: ${commandName} must be run from the local @servicetitan/startup installation`
+                );
+                expect(process.exit).toHaveBeenCalledWith(1);
+            });
+
+            describe('when command allows running from global location', () => {
+                beforeEach(() => {
+                    (mockCommand.constructor as any).allowRunFromGlobal = true;
+                });
+
+                afterEach(() => {
+                    delete (mockCommand.constructor as any).allowRunFromGlobal;
+                });
+
+                itDoesNothing();
+            });
+
+            describe('when parent process has already checked location', () => {
+                beforeEach(() => (process.env.SKIP_STARTUP_LOCATION_CHECK = 'true'));
+
+                itDoesNothing();
+            });
+        });
+    });
+});

package/src/cli/utils/__tests__/cli-git.test.ts

@@ -1,6 +1,5 @@
-import { runCommandOutput } from '../cli-os';
-
 import { gitGetBranch, gitGetCommitHash } from '../cli-git';
+import { runCommandOutput } from '../cli-os';
 
 jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
 

package/src/cli/utils/__tests__/cli-npm.test.ts

@@ -1,19 +1,27 @@
-import { runCommand, runCommandOutput } from '../cli-os';
-
 import {
     npmGetPackageVersions,
     npmGetPackageVersionsDetails,
+    npmGetProjectRoot,
     npmPackageSet,
     npmPublish,
+    npmRemoveTag,
     npmTagVersion,
     npmUnpublish,
     npmView,
 } from '../cli-npm';
+import { runCommand, runCommandOutput } from '../cli-os';
 
 jest.mock('../cli-os', () => ({
     runCommand: jest.fn().mockResolvedValue(undefined),
     runCommandOutput: jest.fn(),
 }));
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: {
+        info: jest.fn(),
+        error: jest.fn(),
+    },
+}));
 
 describe('[startup] Cli Utils (Npm)', () => {
     beforeEach(() => jest.resetAllMocks());
@@ -133,6 +141,26 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
+    describe(npmGetProjectRoot.name, () => {
+        const output = 'foo\n';
+
+        beforeEach(() => {
+            jest.mocked(runCommandOutput).mockReturnValue(output);
+        });
+
+        const subject = () => npmGetProjectRoot();
+
+        itRunsCommandOutput(subject, 'npm prefix', {
+            quiet: true,
+            stdio: ['inherit', 'pipe', 'ignore'],
+            timeout: 10000,
+        });
+
+        test('returns trimmed output', () => {
+            expect(subject()).toEqual(output.trim());
+        });
+    });
+
     describe(npmPackageSet.name, () => {
         let args: Parameters<typeof npmPackageSet>;
 
@@ -204,6 +232,27 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
+    describe(npmRemoveTag.name, () => {
+        let args: Parameters<typeof npmRemoveTag>[0];
+
+        beforeEach(() => {
+            args = {
+                packageName: '{packageName}',
+                tag: '{tag}',
+            };
+        });
+
+        const subject = () => npmRemoveTag(args);
+
+        itRunsCommand(subject, 'npm dist-tag rm {packageName} {tag}');
+
+        describe('with a registry', () => {
+            beforeEach(() => (args.registry = '{registry}'));
+
+            itRunsCommand(subject, 'npm dist-tag --registry={registry} rm {packageName} {tag}');
+        });
+    });
+
     describe(npmView.name, () => {
         const packageInfo = { name: 'foo', version: '1.0.0', versions: [], time: {} };
         let args: Parameters<typeof npmView>[0];

package/src/cli/utils/__tests__/cli-os.test.ts

@@ -1,7 +1,6 @@
 import { execSync, spawn } from 'child_process';
-
-import { runCommand, runCommandOutput } from '../cli-os';
 import { log } from '../../../utils';
+import { runCommand, runCommandOutput } from '../cli-os';
 
 jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
 jest.mock('../../../utils', () => ({ log: { info: jest.fn() } })); // suppress log output

package/src/cli/utils/__tests__/compile.test.ts

@@ -1,6 +1,6 @@
 import { log } from '../../../utils';
-import { lernaExec } from '../lerna-exec';
 import { compile } from '../compile';
+import { lernaExec } from '../lerna-exec';
 
 jest.mock('../lerna-exec', () => ({
     lernaExec: jest.fn(),

package/src/cli/utils/__tests__/copy-files.test.ts

@@ -5,7 +5,6 @@ import cpx from 'cpx2';
 import fs from 'fs';
 import { getFolders, log } from '../../../utils';
 import * as compileSassModule from '../compile-sass';
-
 import { copyFiles, styleExtensions, supportedExtensions } from '../copy-files';
 
 jest.mock('cpx2', () => ({

package/src/cli/utils/__tests__/eslint.test.ts

@@ -1,6 +1,6 @@
 import { fs, vol } from 'memfs';
-import { ESLint } from 'eslint';
 
+import { ESLint } from 'eslint';
 import { getDestinationFolders } from '../../../utils';
 import { eslint } from '../eslint';
 

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -1,9 +1,8 @@
 import { isCI } from '@servicetitan/install';
 import execa from 'execa';
-
 import { log } from '../../../utils';
-import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 import { lernaExec } from '../lerna-exec';
+import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 
 jest.mock('@servicetitan/install');
 jest.mock('execa');

package/src/cli/utils/__tests__/maybe-create-git-folder.test.ts

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 
 jest.mock('fs', () => fs);

package/src/cli/utils/__tests__/set-node-options.test.ts

@@ -1,7 +1,6 @@
 import os from 'os';
 import { getConfigurationSafe } from '../../../utils';
 import { Command } from '../../commands/types';
-
 import { setNodeOptions } from '../set-node-options';
 
 jest.mock('os', () => ({

package/src/cli/utils/__tests__/stylelint.test.ts

@@ -1,6 +1,6 @@
 import { lint } from 'stylelint';
-import { stylelint } from '../stylelint';
 import { getDestinationFolders, getStylelintConfiguration } from '../../../utils';
+import { stylelint } from '../stylelint';
 
 jest.mock('stylelint', () => ({ lint: jest.fn() }));
 

package/src/cli/utils/bundle.ts

@@ -1,11 +1,9 @@
+import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
-import crypto from 'crypto';
 import { getPortPromise } from 'portfinder';
-
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
-
 import {
     getPackageName,
     hasHeadlessBundle,

package/src/cli/utils/check-startup-location.ts

@@ -0,0 +1,21 @@
+import { CommandName, log } from '../../utils';
+import { Command } from '../commands';
+import { npmGetProjectRoot } from './cli-npm';
+
+export function checkStartupLocation(commandName: CommandName, command: Command) {
+    const allowRunFromGlobal = (command.constructor as typeof Command).allowRunFromGlobal;
+    if (allowRunFromGlobal || process.env.SKIP_STARTUP_LOCATION_CHECK) {
+        return;
+    }
+
+    const projectRoot = npmGetProjectRoot();
+    if (projectRoot && __dirname.startsWith(projectRoot)) {
+        process.env.SKIP_STARTUP_LOCATION_CHECK = 'true';
+        return;
+    }
+
+    log.error(
+        `Error: ${commandName} must be run from the local @servicetitan/startup installation`
+    );
+    process.exit(1);
+}

package/src/cli/utils/cli-npm.ts

@@ -42,6 +42,15 @@ export function npmGetPackageVersionsDetails(registry: string, packageName: stri
     }
 }
 
+export function npmGetProjectRoot() {
+    return runCommandOutput('npm prefix', {
+        quiet: true,
+        // ignore stderr because any error here is fundamental and will be repeated elsewhere
+        stdio: ['inherit', 'pipe', 'ignore'],
+        timeout: NPM_TIMEOUT,
+    }).trim();
+}
+
 export async function npmUnpublish(registry: string, packageName: string, packageVersion: string) {
     await runCommand(`npm unpublish ${packageName}@${packageVersion} --registry ${registry}`, {
         timeout: NPM_TIMEOUT,
@@ -74,6 +83,19 @@ export async function npmTagVersion({
     );
 }
 
+export async function npmRemoveTag({
+    packageName,
+    registry,
+    tag,
+}: {
+    packageName: string;
+    registry?: string;
+    tag: string;
+}) {
+    const registryFlag = registry ? `--registry=${registry} ` : '';
+    await runCommand(`npm dist-tag ${registryFlag}rm ${packageName} ${tag}`);
+}
+
 export interface NPMPackageInfo {
     'name': string;
     'version': string;

package/src/cli/utils/compile-less.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
-import path from 'path';
 import less from 'less';
+import path from 'path';
 const lessPackageImporter = require('less-plugin-npm-import');
 
 export async function compileLess(filePath: string) {

package/src/cli/utils/constants.ts

@@ -0,0 +1 @@
+export const DRY_RUN_PREFIX = '(dry-run) ';

package/src/cli/utils/copy-files.ts

@@ -2,7 +2,6 @@ import cpx from 'cpx2';
 import fs from 'fs';
 import { glob } from 'glob';
 import DtsCreator from 'typed-css-modules';
-
 import { getFolders, log } from '../../utils';
 import { compileLess } from './compile-less';
 import { compileSass } from './compile-sass';

package/src/cli/utils/eslint.ts

@@ -1,9 +1,7 @@
 import { ESLint } from 'eslint';
-
 import { getDestinationFolders, getESLintConfiguration, log } from '../../utils';
-import { CommandArgs } from '../commands';
 
-interface Args extends CommandArgs {
+interface Args {
     fix?: boolean;
     paths: string[];
 }

package/src/cli/utils/index.ts

@@ -1,11 +1,13 @@
 export * from './bundle';
 export * from './check-args';
+export * from './check-startup-location';
 export * from './cli-git';
 export * from './cli-npm';
 export * from './cli-os';
 export * from './compile';
 export * from './compile-less';
 export * from './compile-sass';
+export * from './constants';
 export * from './copy-files';
 export * from './eslint';
 export * from './get-module-type';

package/src/cli/utils/lerna-exec.ts

@@ -1,7 +1,6 @@
 import { isCI } from '@servicetitan/install';
 import execa, { StdioOption } from 'execa';
 import os from 'node:os';
-
 import { log } from '../../utils';
 import { maybeCreateGitFolder } from './maybe-create-git-folder';