@servicetitan/startup 24.0.3 → 24.1.0

package/src/cli/commands/eslint.ts

@@ -11,6 +11,10 @@ interface Args {
 export class ESLintCommand implements Command {
     constructor(private args: Args) {}
 
+    description() {
+        return undefined;
+    }
+
     @logErrors
     async execute(): Promise<void> {
         const { _: paths, fix } = this.args;

package/src/cli/commands/get-command.ts

@@ -0,0 +1,50 @@
+import { CommandName } from '../../utils';
+
+import { Build } from './build';
+import { BundlePackage } from './bundle-package';
+import { ESLintCommand } from './eslint';
+import { Init } from './init';
+import { Install } from './install';
+import { KendoUILicense } from './kendo-ui-license';
+import { Lint } from './lint';
+import { MFEPackageClean, MFEPackagePublish, MFEPublish } from './mfe-publish';
+import { PreparePackage } from './prepare-package';
+import { Start } from './start';
+import { StylesCheck } from './styles-check';
+import { Tests } from './tests';
+import { Command } from './types';
+
+type Newable<T> = new (...args: any[]) => T;
+
+export function getCommand(name: CommandName): Newable<Command> | undefined {
+    switch (name) {
+        case CommandName.build:
+            return Build;
+        case CommandName['bundle-package']:
+            return BundlePackage;
+        case CommandName.eslint:
+            return ESLintCommand;
+        case CommandName.init:
+            return Init;
+        case CommandName.install:
+            return Install;
+        case CommandName['kendo-ui-license']:
+            return KendoUILicense;
+        case CommandName.lint:
+            return Lint;
+        case CommandName['mfe-package-clean']:
+            return MFEPackageClean;
+        case CommandName['mfe-package-publish']:
+            return MFEPackagePublish;
+        case CommandName['mfe-publish']:
+            return MFEPublish;
+        case CommandName['prepare-package']:
+            return PreparePackage;
+        case CommandName.start:
+            return Start;
+        case CommandName['styles-check']:
+            return StylesCheck;
+        case CommandName.test:
+            return Tests;
+    }
+}

package/src/cli/commands/get-user-commands.ts

@@ -0,0 +1,19 @@
+import { CommandName } from '../../utils';
+
+import { getCommand } from './get-command';
+
+interface UserCommand {
+    name: string;
+    description: string;
+}
+
+export function getUserCommands() {
+    return Object.values(CommandName)
+        .sort((a, b) => a.localeCompare(b))
+        .map(name => {
+            const Command = getCommand(name)!;
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            return { name, description: new Command({ _: [] }).description() };
+        })
+        .filter(({ description }) => !!description) as UserCommand[];
+}

package/src/cli/commands/index.ts

@@ -1,6 +1,8 @@
 export * from './build';
 export * from './bundle-package';
 export * from './eslint';
+export * from './get-command';
+export * from './get-user-commands';
 export * from './init';
 export * from './install';
 export * from './kendo-ui-license';
@@ -10,7 +12,4 @@ export * from './start';
 export * from './tests';
 export * from './styles-check';
 export * from './mfe-publish';
-
-export interface Command {
-    execute(): Promise<void>;
-}
+export * from './types';

package/src/cli/commands/init.ts

@@ -7,13 +7,17 @@ import { log, logErrors } from '../../utils';
 import { Command } from './';
 
 interface Args {
-    react18?: boolean;
+    react17?: boolean;
     output?: string;
 }
 
 export class Init implements Command {
     constructor(private args: Args) {}
 
+    description() {
+        return 'generate empty project';
+    }
+
     @logErrors
     async execute() {
         const destination = path.resolve(this.args.output ?? '.');
@@ -25,11 +29,11 @@ export class Init implements Command {
 
         await copyFiles('template', destination);
 
-        if (this.args.react18) {
+        if (!this.args.react17) {
             await copyFiles('template-react18', destination);
         }
 
-        log.info(`copied${this.args.react18 ? ' React 18' : ''} template to ${destination}`);
+        log.info(`copied${this.args.react17 ? ' React 17' : ''} template to ${destination}`);
     }
 }
 

package/src/cli/commands/install.ts

@@ -4,6 +4,10 @@ import { log, logErrors, getStartupVersion } from '../../utils';
 import { Command } from '.';
 
 export class Install implements Command {
+    description() {
+        return 'install project dependencies';
+    }
+
     @logErrors
     async execute() {
         const installCommand = process.env.CI ? 'ci' : 'i';

package/src/cli/commands/kendo-ui-license.ts

@@ -30,6 +30,10 @@ const LICENSE = Buffer.from(ENCODED_LICENSE, 'base64').toString('ascii');
 const LICENSING_PACKAGE = '@progress/kendo-licensing';
 
 export class KendoUILicense implements Command {
+    description() {
+        return 'install KendoReact license key';
+    }
+
     async execute() {
         if (!isModuleInstalled(LICENSING_PACKAGE)) {
             return;

package/src/cli/commands/lint.ts

@@ -32,6 +32,10 @@ export class Lint implements Command {
         this.paths = [...args._];
     }
 
+    description() {
+        return 'run eslint and stylelint';
+    }
+
     async execute() {
         await this.checkStyles();
         await this.eslint();

package/src/cli/commands/mfe-publish.ts

@@ -23,13 +23,14 @@ import { getDefaultBuildVersion } from '../utils/publish';
 import { Command } from '.';
 
 interface ArgsPackagePublish {
+    branch?: string;
     build?: string;
+    concurrency?: number;
     dry?: boolean;
     force?: boolean;
-    branch?: string;
-    tag?: string | false;
     noTag?: string;
     registry?: string;
+    tag?: string | false;
 }
 
 interface ArgsPackageClean {
@@ -44,6 +45,10 @@ interface Args extends ArgsPackagePublish, ArgsPackageClean {
 export class MFEPublish implements Command {
     constructor(private args: Args) {}
 
+    description() {
+        return 'publish or unpublish MFE packages';
+    }
+
     @logErrors
     async execute() {
         let packages = splitPackagesByType(getPackages())[PackageType.Webpack] ?? [];
@@ -67,25 +72,35 @@ export class MFEPublish implements Command {
 
         await lernaExec({
             'cmd': `startup mfe-package-${this.args.clean ? 'clean' : 'publish'}`,
+            'concurrency': this.args.concurrency ?? 1,
             'scope': packages.map(({ name }) => name),
             'stream': true,
-            '--': [
-                ...[this.args.build ? `--build ${this.args.build}` : undefined],
-                ...[this.args.branch ? `--branch ${this.args.branch}` : undefined],
-                ...[this.args.tag ? `--tag ${this.args.tag}` : undefined],
-                ...[this.args.tag === false ? `--no-tag` : undefined],
-                ...[this.args.dry ? '--dry' : undefined],
-                ...[this.args.force ? '--force' : undefined],
-                ...[this.args.count ? `--count ${this.args.count}` : undefined],
-                ...[this.args.registry ? `--registry ${this.args.registry}` : undefined],
-            ].filter(item => !!item) as string[],
+            '--': this.getPublishOptions(),
         });
     }
+
+    getPublishOptions() {
+        const { build, branch, count, dry, force, registry, tag } = this.args;
+        return [
+            ...[branch && `--branch ${branch}`],
+            ...[build && `--build ${build}`],
+            ...[count && `--count ${count}`],
+            ...[dry && '--dry'],
+            ...[force && '--force'],
+            ...[registry && `--registry ${registry}`],
+            ...[tag && `--tag ${tag}`],
+            ...[tag === false && `--no-tag`],
+        ].filter(item => !!item) as string[];
+    }
 }
 
 export class MFEPackagePublish implements Command {
     constructor(private args: ArgsPackagePublish) {}
 
+    description() {
+        return undefined;
+    }
+
     @logErrors
     async execute() {
         if (!isWebComponent()) {
@@ -190,6 +205,10 @@ export class MFEPackagePublish implements Command {
 export class MFEPackageClean implements Command {
     constructor(private args: ArgsPackageClean) {}
 
+    description() {
+        return undefined;
+    }
+
     @logErrors
     async execute() {
         if (!isWebComponent()) {

package/src/cli/commands/prepare-package.ts

@@ -9,6 +9,10 @@ interface Args {
 export class PreparePackage implements Command {
     constructor(private args: Args) {}
 
+    description() {
+        return undefined;
+    }
+
     @logErrors
     async execute() {
         if (!this.args.watch) {

package/src/cli/commands/start.ts

@@ -14,6 +14,10 @@ interface Args {
 export class Start implements Command {
     constructor(private args: Args) {}
 
+    description() {
+        return 'run project in development mode';
+    }
+
     @logErrors
     async execute() {
         const packages = splitPackagesByType(

package/src/cli/commands/styles-check.ts

@@ -121,6 +121,10 @@ function checkStylesWebComponent(files: FileInfo[]) {
 }
 
 export class StylesCheck implements Command {
+    description() {
+        return undefined;
+    }
+
     // eslint-disable-next-line @typescript-eslint/require-await
     async execute() {
         if (isLegacy()) {

package/src/cli/commands/tests.ts

@@ -9,6 +9,10 @@ import { Command } from '.';
 export class Tests implements Command {
     constructor(private args: Config.Argv) {}
 
+    description() {
+        return 'run tests';
+    }
+
     @logErrors
     async execute() {
         const jestConfig = getJestConfigCLI(this.args);

package/src/cli/commands/types.ts

@@ -0,0 +1,4 @@
+export interface Command {
+    execute(): Promise<void>;
+    description(): string | undefined;
+}

package/src/cli/index.ts

@@ -1,69 +1,23 @@
 import execa from 'execa';
 import { argv, Arguments } from 'yargs';
-
-import { CommandName, log } from '../utils';
-import {
-    Build,
-    BundlePackage,
-    Command,
-    ESLintCommand,
-    Init,
-    Install,
-    KendoUILicense,
-    Lint,
-    MFEPackageClean,
-    MFEPackagePublish,
-    MFEPublish,
-    PreparePackage,
-    Start,
-    StylesCheck,
-    Tests,
-} from './commands';
+import { CommandName, getStartupVersion, log } from '../utils';
+import { getCommand, getUserCommands } from './commands';
 import { setNodeOptions } from './utils';
 
-interface Newable<T> {
-    new (...args: any[]): T;
-}
-
-function getCommand(name: CommandName): Newable<Command> {
-    switch (name) {
-        case CommandName.build:
-            return Build;
-        case CommandName['bundle-package']:
-            return BundlePackage;
-        case CommandName.eslint:
-            return ESLintCommand;
-        case CommandName.init:
-            return Init;
-        case CommandName.install:
-            return Install;
-        case CommandName['kendo-ui-license']:
-            return KendoUILicense;
-        case CommandName.lint:
-            return Lint;
-        case CommandName['mfe-package-clean']:
-            return MFEPackageClean;
-        case CommandName['mfe-package-publish']:
-            return MFEPackagePublish;
-        case CommandName['mfe-publish']:
-            return MFEPublish;
-        case CommandName['prepare-package']:
-            return PreparePackage;
-        case CommandName.start:
-            return Start;
-        case CommandName['styles-check']:
-            return StylesCheck;
-        case CommandName.test:
-            return Tests;
-        default:
-            log.error(`${name}: command not found!`);
-            process.exit(127);
-    }
+const argvSync = argv as Arguments;
+const name = argvSync._[0]?.toString() as CommandName;
+if (!name) {
+    log.info(`startup cli v${getStartupVersion()}`);
+    usage();
+    process.exit(0);
 }
 
-const argvSync = argv as Arguments;
-const name = argvSync._[0].toString() as CommandName;
 const Command = getCommand(name);
+if (!Command) {
+    log.error(`Unknown command: "${name}"`);
+    usage();
+    process.exit(127);
+}
 
 if (setNodeOptions(name)) {
     // Run command in child process with amended NODE_OPTIONS
@@ -77,3 +31,17 @@ if (setNodeOptions(name)) {
         process.exit(1);
     });
 }
+
+function usage() {
+    write('\nUsage:\n');
+
+    const commands = getUserCommands().filter(({ name }) => !!name);
+    const maxNameLength = commands.reduce((result, { name }) => Math.max(result, name.length), 0);
+    commands.forEach(({ name, description }) => {
+        write(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
+    });
+}
+
+function write(text: string) {
+    return console.info(text); // eslint-disable-line no-console
+}

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

@@ -31,6 +31,8 @@ describe(`${lernaExec.name}`, () => {
         { arg: { parallel: true }, option: '--parallel' },
         { arg: { stream: true }, option: '--stream' },
         { arg: { bail: false }, option: '--no-bail' },
+        { arg: { concurrency: 1 }, option: '--concurrency=1' },
+        { arg: { concurrency: 0 }, option: '--concurrency=0' },
     ] as { arg: Partial<typeof args>; option: string }[])('with $arg', ({ arg, option }) => {
         beforeEach(() => Object.assign(args, arg));
 

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

@@ -4,6 +4,7 @@ import { log } from '../../utils';
 interface Args {
     'bail'?: boolean;
     'cmd': string;
+    'concurrency'?: number;
     'scope'?: string[];
     'stream'?: boolean;
     'parallel'?: boolean;
@@ -33,5 +34,8 @@ function getOptions(args: Args) {
     if (args.stream) {
         result.push('--stream');
     }
+    if (typeof args.concurrency === 'number') {
+        result.push(`--concurrency=${args.concurrency}`);
+    }
     return result;
 }

package/src/utils/__tests__/get-packages.test.ts

@@ -1,5 +1,7 @@
 import execa from 'execa';
 import { isBundle, isLegacy } from '../get-configuration';
+import { log } from '../log';
+import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 
 import {
     Package,
@@ -11,6 +13,7 @@ import {
 
 jest.mock('execa', () => ({ sync: jest.fn() }));
 jest.mock('../get-configuration');
+jest.mock('../maybe-create-git-folder');
 
 describe('[startup] Utils', () => {
     const packages: Pick<Package, 'name' | 'location' | 'type'>[] = [
@@ -19,6 +22,15 @@ describe('[startup] Utils', () => {
         { name: 'baz', location: 'packages/baz', type: PackageType.Webpack },
     ];
 
+    beforeEach(() => jest.clearAllMocks());
+
+    function expectExecaToBeCalledWith(command: string, options?: execa.SyncOptions) {
+        const [file, ...args] = command.split(' ');
+        const { calls } = jest.mocked(execa.sync).mock;
+        const expected: any[] = [file, args, ...(options ? [options] : [])];
+        expect(calls).toContainEqual(expect.arrayContaining(expected));
+    }
+
     describe(`${getPackages.name}`, () => {
         let options: Parameters<typeof getPackages>[0] | undefined;
         let dependencies: Record<string, string[]> | undefined;
@@ -40,6 +52,16 @@ describe('[startup] Utils', () => {
             return result;
         }
 
+        function resolvePackages(args: string[]) {
+            if (args.includes('--graph')) {
+                return packageGraph();
+            }
+            if (args.includes('--scope')) {
+                return scopedPackages().map(({ type, ...pkg }) => pkg);
+            }
+            return packages.map(({ type, ...pkg }) => pkg);
+        }
+
         beforeEach(() => {
             options = undefined;
             dependencies = undefined;
@@ -52,15 +74,7 @@ describe('[startup] Utils', () => {
             );
             // @ts-expect-error because implementation doesn't match all exec.sync signatures
             jest.mocked(execa.sync).mockImplementation((_: string, args: string[]): any => {
-                return {
-                    stdout: JSON.stringify(
-                        args.includes('--graph')
-                            ? packageGraph()
-                            : args.includes('--scope')
-                            ? scopedPackages().map(({ type, ...pkg }) => pkg)
-                            : packages.map(({ type, ...pkg }) => pkg)
-                    ),
-                };
+                return { stdout: JSON.stringify(resolvePackages(args)) };
             });
         });
 
@@ -68,7 +82,34 @@ describe('[startup] Utils', () => {
 
         test('returns lerna packages with type metadata', () => {
             expect(subject()).toEqual(packages);
-            expect(execa.sync).toHaveBeenCalledWith('npx', 'lerna la --json'.split(' '));
+            expectExecaToBeCalledWith('npx lerna la --json');
+        });
+
+        test('conditionally creates .git folder', () => {
+            subject();
+
+            expect(maybeCreateGitFolder).toHaveBeenCalled();
+        });
+
+        describe('when running on Windows', () => {
+            const originalPlatform = process.platform;
+            beforeEach(() => {
+                Object.defineProperty(process, 'platform', { value: 'win32' });
+            });
+
+            afterEach(() => {
+                Object.defineProperty(process, 'platform', { value: originalPlatform });
+            });
+
+            test('sets NX_CACHE_PROJECT_GRAPH=false', () => {
+                subject();
+
+                expectExecaToBeCalledWith('npx lerna la --json', {
+                    extendEnv: true,
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    env: { NX_CACHE_PROJECT_GRAPH: 'false' },
+                });
+            });
         });
 
         describe.each(['scope', 'ignore'])('with "%s"', option => {
@@ -77,10 +118,7 @@ describe('[startup] Utils', () => {
             test(`passes "${option}" option to lerna`, () => {
                 subject();
 
-                expect(execa.sync).toHaveBeenCalledWith(
-                    'npx',
-                    `lerna la --${option} foo --json`.split(' ')
-                );
+                expectExecaToBeCalledWith(`npx lerna la --${option} foo --json`);
             });
         });
 
@@ -101,6 +139,18 @@ describe('[startup] Utils', () => {
                 });
             });
         });
+
+        describe('when execa returns unexpected output', () => {
+            beforeEach(() =>
+                jest.mocked(execa.sync).mockReturnValue({ stdout: Buffer.from('foo') } as any)
+            );
+
+            test('throws an error and logs the output', () => {
+                const logSpy = jest.spyOn(log, 'error');
+                expect(() => subject()).toThrow();
+                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('\nfoo'));
+            });
+        });
     });
 
     describe(`${getPackagesGraph.name}`, () => {
@@ -118,7 +168,7 @@ describe('[startup] Utils', () => {
 
         test('returns lerna package graph', () => {
             expect(subject()).toEqual(packageGraph);
-            expect(execa.sync).toHaveBeenCalledWith('npx', 'lerna la --graph'.split(' '));
+            expectExecaToBeCalledWith('npx lerna la --graph');
         });
 
         describe.each(['scope', 'ignore'])('with "%s"', option => {
@@ -127,16 +177,13 @@ describe('[startup] Utils', () => {
             test(`passes "${option}" option to lerna`, () => {
                 subject();
 
-                expect(execa.sync).toHaveBeenCalledWith(
-                    'npx',
-                    `lerna la --${option} foo --graph`.split(' ')
-                );
+                expectExecaToBeCalledWith(`npx lerna la --${option} foo --graph`);
             });
         });
     });
 
     describe(`${splitPackagesByType.name}`, () => {
-        const subject = (packages: Package[]) => splitPackagesByType(packages as Package[]);
+        const subject = (packages: Package[]) => splitPackagesByType(packages);
 
         test('groups packages by type', () => {
             expect(subject(packages as Package[])).toEqual(

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

@@ -0,0 +1,41 @@
+import { fs, vol } from 'memfs';
+
+import { maybeCreateGitFolder } from '../maybe-create-git-folder';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] Utils`, () => {
+    describe(`${maybeCreateGitFolder.name}`, () => {
+        const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
+
+        beforeEach(() => vol.fromJSON({}));
+
+        afterEach(() => vol.reset);
+
+        const subject = () => maybeCreateGitFolder();
+
+        describe('when running on Windows', () => {
+            beforeEach(() => {
+                Object.defineProperty(process, 'platform', { value: 'win32' });
+            });
+
+            test('creates .git folder', () => {
+                subject();
+
+                expect(mkdirSpy).toHaveBeenCalledWith('.git');
+            });
+        });
+
+        describe('when not running on Windows', () => {
+            beforeEach(() => {
+                Object.defineProperty(process, 'platform', { value: 'linux' });
+            });
+
+            test('does not create .git folder', () => {
+                subject();
+
+                expect(mkdirSpy).not.toHaveBeenCalledWith();
+            });
+        });
+    });
+});