@servicetitan/startup 32.1.0 → 32.3.0

package/src/cli/commands/test/runners/__tests__/vitest.test.ts

@@ -66,6 +66,10 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         expect(vitest.close).toHaveBeenCalled();
     });
 
+    function expectCallsVitestWithConfig(config: Record<string, any>) {
+        expect(startVitest).toHaveBeenCalledWith('test', [], {}, { test: config });
+    }
+
     describe('with package.json config', () => {
         const packageJSONConfig: ViteUserConfig['test'] = { bail: 1, globals: false };
 
@@ -78,19 +82,40 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         test('merges package.json config with default config', async () => {
             await subject();
 
-            expect(startVitest).toHaveBeenCalledWith(
-                'test',
-                [],
-                {},
-                { test: { ...defaultConfig, ...packageJSONConfig } }
-            );
+            expectCallsVitestWithConfig({ ...defaultConfig, ...packageJSONConfig });
+        });
+
+        describe('with omitDefault', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    'package.json': JSON.stringify({
+                        cli: {
+                            vitest: {
+                                ...packageJSONConfig,
+                                omitDefault: ['coverage.include', 'environment'],
+                            },
+                        },
+                    }),
+                });
+            });
+
+            test('omits specified defaults', async () => {
+                await subject();
+
+                const { environment, coverage, ...restDefault } = defaultConfig;
+                const { include, ...restCoverage } = coverage as any;
+                const defaultSansOmitted = { coverage: restCoverage, ...restDefault };
+
+                expectCallsVitestWithConfig({ ...defaultSansOmitted, ...packageJSONConfig });
+            });
         });
     });
 
     describe('with vite test config', () => {
-        const viteTestConfig: ViteUserConfig['test'] = { name: 'foo', watch: false };
+        let viteTestConfig: NonNullable<ViteUserConfig['test']>;
 
         beforeEach(() => {
+            viteTestConfig = { name: 'foo', watch: false };
             jest.mocked(resolveConfig).mockResolvedValue({
                 viteConfig: { test: viteTestConfig },
             } as any);
@@ -99,13 +124,57 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         test('merges vite test config with default config', async () => {
             await subject();
 
-            expect(startVitest).toHaveBeenCalledWith(
-                'test',
-                [],
-                {},
-                { test: { ...defaultConfig, ...viteTestConfig } }
-            );
+            expectCallsVitestWithConfig({ ...defaultConfig, ...viteTestConfig });
         });
+
+        describe('with "coverage.include"', () => {
+            const defaultCoverageInclude = (defaultConfig.coverage as any).include;
+            const include = ['packages/foo'];
+
+            beforeEach(() => {
+                Object.assign(viteTestConfig, {
+                    coverage: { include },
+                });
+            });
+
+            test('merges default and custom "coverage.include"', async () => {
+                await subject();
+
+                expectCallsVitestWithConfig(
+                    expect.objectContaining({
+                        coverage: {
+                            ...defaultConfig.coverage,
+                            include: [...defaultCoverageInclude, ...include],
+                        },
+                    })
+                );
+            });
+
+            describe('when omitDefault contains "coverage.include"', () => {
+                beforeEach(() => {
+                    vol.fromJSON({
+                        'package.json': JSON.stringify({
+                            cli: { vitest: { omitDefault: ['coverage.include'] } },
+                        }),
+                    });
+                });
+
+                test('omits default "coverage.include"', async () => {
+                    await subject();
+
+                    expectCallsVitestWithConfig(
+                        expect.objectContaining({
+                            coverage: {
+                                ...defaultConfig.coverage,
+                                include,
+                            },
+                        })
+                    );
+                });
+            });
+        });
+
+        test('can use omitDefault to replace coverage.include', () => {});
     });
 
     describe('with command line options', () => {

package/src/cli/commands/test/runners/vitest.ts

@@ -1,6 +1,6 @@
 import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
 import { startVitest, parseCLI, resolveConfig } from 'vitest/node';
-import { getVitestConfiguration, log } from '../../../../utils';
+import { getVitestConfiguration, log, omit } from '../../../../utils';
 
 type VitestConfig = NonNullable<ViteUserConfig['test']>;
 
@@ -58,8 +58,10 @@ function getDefaultConfig(): VitestConfig {
 async function getUserConfig(): Promise<ViteUserConfig> {
     const { viteConfig } = await resolveConfig();
 
+    const { omitDefault = [], ...config } = getVitestConfiguration();
+
     const result = mergeConfig(
-        mergeConfig(getDefaultConfig(), getVitestConfiguration()),
+        mergeConfig(omit(getDefaultConfig(), omitDefault), config),
         viteConfig.test ?? {}
     );
 

package/src/cli/commands/test/tests.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { Config } from '@jest/types';
 import { getConfiguration, logErrors } from '../../../utils';
 import { Command } from '../types';
@@ -5,26 +6,35 @@ import { Jest, Vitest } from './runners';
 
 type Args = Config.Argv & {
     runner?: 'jest' | 'vitest';
+    runnerArgs?: string[];
 };
 
 /**
  * This class is named "Tests" instead of "Test" because the corresponding
  * "test.ts" would be interpreted as a test file.
  */
-export class Tests implements Command {
-    readonly greedy = true;
-
-    constructor(private readonly args: Args) {}
-
-    description() {
-        return 'run tests';
-    }
+export class Tests extends Command<Args> {
+    static readonly description = 'Run tests';
+    static readonly greedy = true;
+    static readonly options = {
+        _: { description: '[runnerArgs...]' },
+        runner: {
+            choices: ['jest', 'vitest'],
+            description: 'Test runner',
+            defaultDescription: 'jest',
+        },
+    };
 
     @logErrors
     async execute() {
-        const { runner = getConfiguration().testRunner ?? 'jest', ...restArgs } = this.args;
+        const {
+            _,
+            runner = getConfiguration().testRunner ?? 'jest',
+            runnerArgs = [],
+            ...restOptions
+        } = this.args;
         if (runner === 'jest') {
-            await new Jest(restArgs).run();
+            await new Jest({ _: [..._, ...runnerArgs], ...restOptions }).run();
         } else if (runner === 'vitest') {
             await new Vitest().run();
         } else {

package/src/cli/commands/types.ts

@@ -1,7 +1,17 @@
-export interface Command {
-    greedy?: boolean;
-    execute(): Promise<void>;
-    description?(): string;
+import type { Options } from 'yargs';
+
+export interface CommandArgs {
+    [key: string]: unknown;
+}
+
+export abstract class Command<T extends CommandArgs = CommandArgs> {
+    static readonly description?: string;
+    static readonly greedy?: boolean;
+    static readonly options?: { [key: string]: Options };
+
+    constructor(protected readonly args: T) {}
+
+    abstract execute(): Promise<void>;
 }
 
 export type Newable<T> = new (...args: any[]) => T;

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

@@ -2,9 +2,9 @@ import path from 'path';
 import { execSync } from 'child_process';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { isCI, TSConfig } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     dry?: boolean;
     releaseVersion: string;
 }
@@ -13,12 +13,10 @@ interface PackageJson {
     name: string;
 }
 
-export class UploadSourcemaps implements Command {
+export class UploadSourcemaps extends Command<Args> {
     #outDir?: string;
     #packageJson?: PackageJson;
 
-    constructor(private readonly args: Args) {}
-
     @logErrors
     // eslint-disable-next-line @typescript-eslint/require-await
     async execute() {

package/src/cli/index.ts

@@ -1,49 +1,72 @@
+import chalk from 'chalk';
 import execa from 'execa';
 import path from 'path';
-import { argv, Arguments } from 'yargs';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import { CommandName, getStartupVersion, log } from '../utils';
-import { getCommand, getUserCommands } from './commands';
+import { Command, getCommand } from './commands';
 import { maybeCreateGitFolder, setNodeOptions } from './utils';
 
-const argvSync = argv as Arguments;
-const name = argvSync._[0]?.toString() as CommandName;
-if (!name) {
-    log.info(`startup cli v${getStartupVersion()}`);
-    usage();
-    process.exit(0);
-}
+Object.values(CommandName)
+    .reduce((y, name) => addCommand(name, y), yargs(hideBin(process.argv)))
+    .usage('Usage: startup <command> [options]')
+    .epilogue(
+        chalk.bold.cyan(`startup cli v${getStartupVersion()}\n`) +
+            `Run ${chalk.bold.cyan('startup <command> --help')} to see command options.\n` +
+            `For detailed documentation, see ${chalk.bold.cyan('https://docs.st.dev/docs/frontend/uikit/startup')}.\n`
+    )
+    .demandCommand(1, '')
+    .strictCommands()
+    .updateStrings({
+        'Unknown command: %s': {
+            one: chalk.bold.red('Unknown command: %s'),
+            other: chalk.bold.red('Unknown command: %s'),
+        } as any,
+    })
+    .version()
+    .wrap(Math.min(100, yargs.terminalWidth()))
+    .help()
+    .parse();
 
-const Command = getCommand(name);
-if (!Command) {
-    log.error(`Unknown command: "${name}"`);
-    usage();
-    process.exit(127);
+function addCommand(name: CommandName, y: typeof yargs) {
+    const klass = getCommand(name)! as typeof Command;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { description, options: { _, ...options } = {} } = klass;
+    const nameWithArgs = name + (_?.description ? ` ${_.description}` : '');
+    const groupedOptions = Object.entries(options).reduce(
+        (result, [key, value]) => {
+            result[key] = { group: 'Command Options:', ...value };
+            return result;
+        },
+        {} as NonNullable<typeof klass.options>
+    );
+    const handler = (argv: any) => handleCommand(name, argv);
+    if (description) {
+        y.command(nameWithArgs, description, groupedOptions, handler);
+    } else {
+        y.command(nameWithArgs, false, groupedOptions, handler);
+    }
+    return y;
 }
 
-checkNodeVersion();
-maybeCreateGitFolder(Command);
+function handleCommand(name: CommandName, argv: any) {
+    const Command = getCommand(name)!;
 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-const command = new Command({ ...argvSync, _: argvSync._.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 => {
-        process.exit(reason.exitCode);
-    });
-} else {
-    command.execute().catch(() => {
-        process.exit(1);
-    });
-}
-
-function usage() {
-    log.text('\nUsage:');
+    checkNodeVersion();
+    maybeCreateGitFolder(Command);
 
-    const commands = getUserCommands().filter(({ name }) => !!name);
-    const maxNameLength = commands.reduce((result, { name }) => Math.max(result, name.length), 0);
-    commands.forEach(({ name, description }) => {
-        log.text(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
-    });
+    // 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 => {
+            process.exit(reason.exitCode);
+        });
+    } else {
+        command.execute().catch(() => {
+            process.exit(1);
+        });
+    }
 }
 
 function checkNodeVersion() {

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

@@ -3,11 +3,11 @@ 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 {
-    [key: string]: unknown;
+interface Args extends CommandArgs {
     watch?: boolean;
 }
 

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

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

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

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

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

@@ -368,6 +368,19 @@ describe('[startup] Cli Utils', () => {
                 });
             });
         });
+
+        describe('with "useWatchConfig"', () => {
+            beforeEach(() => (options = { useWatchConfig: true }));
+
+            test('sets mode to "development"', async () => {
+                await subject();
+
+                expect(createWebpackConfig).toHaveBeenCalledWith(
+                    { configuration: { mode: 'development' } },
+                    expect.anything()
+                );
+            });
+        });
     });
 
     describe(`${bundle.name} (watch mode)`, () => {

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

@@ -7,6 +7,8 @@ import {
     npmPublish,
     npmTagVersion,
     npmUnpublish,
+    npmView,
+    npmWhoAmI,
 } from '../cli-npm';
 
 jest.mock('../cli-os', () => ({
@@ -202,4 +204,91 @@ describe('[startup] Cli Utils (Npm)', () => {
             );
         });
     });
+
+    describe(npmView.name, () => {
+        const packageInfo = { name: 'foo', version: '1.0.0', versions: [], time: {} };
+        let args: Parameters<typeof npmView>[0];
+
+        beforeEach(() => {
+            args = { packageName: '{packageName}' };
+            jest.mocked(runCommandOutput).mockReturnValue(JSON.stringify(packageInfo));
+        });
+
+        const subject = () => npmView(args);
+
+        itRunsCommandOutput(subject, 'npm view --json {packageName}', {
+            quiet: true,
+            timeout: 10000,
+        });
+
+        test('returns package info', () => {
+            expect(subject()).toEqual(packageInfo);
+        });
+
+        describe('with a registry', () => {
+            beforeEach(() => (args.registry = '{registry}'));
+
+            itRunsCommandOutput(
+                subject,
+                'npm view --json --registry={registry} {packageName}',
+                expect.anything()
+            );
+        });
+
+        describe('when command fails', () => {
+            const error = new Error('Oops!');
+
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementation(() => {
+                    throw error;
+                });
+            });
+
+            test('returns undefined', () => {
+                expect(subject()).toBeUndefined();
+            });
+        });
+    });
+
+    describe(npmWhoAmI.name, () => {
+        const username = 'Foo\n';
+        let args: Parameters<typeof npmWhoAmI>[0];
+
+        beforeEach(() => {
+            args = undefined;
+            jest.mocked(runCommandOutput).mockReturnValue(username);
+        });
+
+        const subject = () => npmWhoAmI(args);
+
+        itRunsCommandOutput(subject, 'npm whoami', {
+            quiet: true,
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: 10000,
+        });
+
+        test('returns trimmed username ', () => {
+            expect(subject()).toEqual(username.trim());
+        });
+
+        describe('with registry', () => {
+            beforeEach(() => (args = { registry: '{registry}' }));
+
+            itRunsCommandOutput(subject, 'npm whoami --registry={registry}', expect.anything());
+        });
+
+        describe('when command fails', () => {
+            const error = new Error('Oops');
+
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementation(() => {
+                    throw error;
+                });
+            });
+
+            test('ignores error and returns undefined', () => {
+                expect(subject()).toBeUndefined();
+            });
+        });
+    });
 });

package/src/cli/utils/__tests__/is-tty.test.ts

@@ -0,0 +1,17 @@
+import { isTTY } from '../is-tty';
+
+describe(`[startup] Utils ${isTTY.name}`, () => {
+    const originalIsTTY = process.stdin.isTTY;
+
+    afterAll(() => process.stdin.isTTY === originalIsTTY);
+
+    const subject = () => isTTY();
+
+    describe.each([true, false])('when process.stdin.isTTY is %s', value => {
+        beforeEach(() => (process.stdin.isTTY = value));
+
+        test(`returns ${value}`, () => {
+            expect(subject()).toBe(value);
+        });
+    });
+});

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

@@ -2,6 +2,7 @@ import { fs, vol } from 'memfs';
 
 import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 import { Init } from '../../commands/init';
+import { Install } from '../../commands/install';
 import { Start } from '../../commands/start';
 
 jest.mock('fs', () => fs);
@@ -28,28 +29,20 @@ describe(`[startup] Utils`, () => {
             });
         }
 
-        describe('when running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'win32' });
-            });
-
-            test('creates .git folder', () => {
-                subject();
+        test('creates .git folder', () => {
+            subject();
 
-                expect(mkdirSpy).toHaveBeenCalledWith('.git');
-            });
+            expect(mkdirSpy).toHaveBeenCalledWith('.git', { recursive: true });
+        });
 
-            describe('when command is Init', () => {
-                beforeEach(() => (command = Init));
+        describe('when command is Init', () => {
+            beforeEach(() => (command = Init));
 
-                itDoesNotCreateGitFolder();
-            });
+            itDoesNotCreateGitFolder();
         });
 
-        describe('when not running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-            });
+        describe('when command is Install', () => {
+            beforeEach(() => (command = Install));
 
             itDoesNotCreateGitFolder();
         });

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

@@ -1,6 +1,6 @@
 import os from 'os';
 import { getConfigurationSafe } from '../../../utils';
-import { Command } from '../../commands';
+import { Command } from '../../commands/types';
 
 import { setNodeOptions } from '../set-node-options';
 
@@ -13,15 +13,11 @@ jest.mock('../../../utils', () => ({
     getConfigurationSafe: jest.fn(() => ({})),
 }));
 
-class MockCommand implements Command {
-    get greedy() {
+class MockCommand extends Command {
+    static get greedy() {
         return true;
     }
 
-    description() {
-        return 'mock command';
-    }
-
     async execute() {
         return Promise.resolve();
     }
@@ -33,12 +29,16 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
     const originalNodeOptions = process.env.NODE_OPTIONS;
     const maxOldSpaceSize = `--max_old_space_size=${DEFAULT_SIZE}`;
     const commandName: any = 'mock';
-    const command = new MockCommand();
+    const command = new MockCommand({});
+    let greedy: boolean;
 
     beforeEach(() => {
+        greedy = true;
         delete process.env.NODE_OPTIONS;
         (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
-        jest.spyOn(command, 'greedy', 'get').mockReturnValue(true);
+        jest.spyOn(command.constructor as typeof Command, 'greedy', 'get').mockImplementation(
+            () => greedy
+        );
     });
 
     afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
@@ -52,7 +52,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
     });
 
     describe('when the command is not greedy', () => {
-        beforeEach(() => jest.spyOn(command, 'greedy', 'get').mockReturnValue(false));
+        beforeEach(() => (greedy = false));
 
         test('returns false and does not set NODE_OPTIONS', () => {
             expect(subject()).toBe(false);

package/src/cli/utils/bundle.ts

@@ -52,7 +52,7 @@ export async function bundle(options: Options = {}) {
 
     log.info(`Bundling ${emitExposedDependencies ? 'exposed dependencies' : 'package'}...`);
 
-    const mode = watch ? 'development' : 'production';
+    const mode = watch || useWatchConfig ? 'development' : 'production';
     const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
     const customConfig = readWebpackConfig({ ...options, fallback });
     const webpackOptions = getWebpackOptions(options, customConfig);
@@ -180,7 +180,7 @@ async function runWatch(config: Configuration) {
     return new Promise<void>((_0, reject) => {
         const watching = compiler.watch({}, e => {
             if (e) {
-                watching.close(() => {
+                watching?.close(() => {
                     reject(e);
                 });
             }