@servicetitan/startup 30.3.0 → 31.0.0

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

@@ -9,8 +9,6 @@ interface Args {
     'code-coverage'?: boolean;
     'stat'?: boolean;
     'watch'?: boolean;
-    'esbuild'?: boolean;
-    'experimental-bundlers'?: boolean;
 }
 
 export class BundlePackage implements Command {
@@ -35,8 +33,6 @@ export class BundlePackage implements Command {
         const options = {
             config,
             codeCoverage: this.args['code-coverage'],
-            esbuild: this.args.esbuild,
-            experimentalBundlers: this.args['experimental-bundlers'],
         };
 
         if (!watch) {

package/src/cli/commands/clean.ts

@@ -0,0 +1,24 @@
+import { exec, execSync } from 'child_process';
+import { log, logErrors } from '../../utils';
+import { Command } from './types';
+
+export class Clean implements Command {
+    description() {
+        return 'resets project to fresh state';
+    }
+
+    @logErrors
+    async execute() {
+        ['npx nx reset', 'npx jest --clearCache', 'npm cache clear --force'].forEach(command => {
+            log.info(`Running: ${command}`);
+            execSync(command, { stdio: ['ignore', 'ignore', 'inherit'] });
+        });
+
+        // Use exec() to avoid error when startup dependencies are deleted while startup is running
+        const command = 'git clean -fdX';
+        log.info(`Running: ${command}`);
+        exec(command);
+
+        return Promise.resolve();
+    }
+}

package/src/cli/commands/eslint.ts

@@ -16,7 +16,7 @@ export class ESLintCommand implements Command {
     }
 
     @logErrors
-    async execute(): Promise<void> {
+    async execute() {
         const { _: paths, fix } = this.args;
         await eslint({ fix, paths });
     }

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

@@ -2,6 +2,7 @@ import { CommandName } from '../../utils';
 
 import { Build } from './build';
 import { BundlePackage } from './bundle-package';
+import { Clean } from './clean';
 import { ConvertEslintConfig } from './convert-eslint-config';
 import { ESLintCommand } from './eslint';
 import { Init } from './init';
@@ -12,45 +13,34 @@ import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
 import { MFEPublish } from './mfe-publish';
 import { PreparePackage } from './prepare-package';
+import { Review } from './review';
+import { RunTask } from './run-task';
 import { Start } from './start';
 import { StylesCheck } from './styles-check';
-import { RunTask } from './run-task';
 import { Tests } from './tests';
 import { Command, Newable } from './types';
 
+const commands: Record<CommandName, Newable<Command>> = {
+    [CommandName.build]: Build,
+    [CommandName['bundle-package']]: BundlePackage,
+    [CommandName['convert-eslint-config']]: ConvertEslintConfig,
+    [CommandName.clean]: Clean,
+    [CommandName.eslint]: ESLintCommand,
+    [CommandName.init]: Init,
+    [CommandName.install]: Install,
+    [CommandName['kendo-ui-license']]: KendoUILicense,
+    [CommandName.lint]: Lint,
+    [CommandName['mfe-package-clean']]: MFEPackageClean,
+    [CommandName['mfe-package-publish']]: MFEPackagePublish,
+    [CommandName['mfe-publish']]: MFEPublish,
+    [CommandName['prepare-package']]: PreparePackage,
+    [CommandName.review]: Review,
+    [CommandName.start]: Start,
+    [CommandName['styles-check']]: StylesCheck,
+    [CommandName.test]: Tests,
+    [CommandName.task]: RunTask,
+};
+
 export function getCommand(name: CommandName): Newable<Command> | undefined {
-    switch (name) {
-        case CommandName.build:
-            return Build;
-        case CommandName['bundle-package']:
-            return BundlePackage;
-        case CommandName['convert-eslint-config']:
-            return ConvertEslintConfig;
-        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;
-        case CommandName.task:
-            return RunTask;
-    }
+    return commands[name];
 }

package/src/cli/commands/index.ts

@@ -12,4 +12,4 @@ export * from './start';
 export * from './tests';
 export * from './styles-check';
 export * from './mfe-publish';
-export * from './types';
+export type * from './types';

package/src/cli/commands/install.ts

@@ -1,19 +1,40 @@
-import execa from 'execa';
-
+import { execSync } from 'child_process';
 import { log, logErrors, getStartupVersion } from '../../utils';
-import { Command } from '.';
+import { Command } from './types';
+
+interface Args {
+    quiet?: boolean;
+    fix?: boolean;
+}
 
 export class Install implements Command {
+    constructor(private readonly args?: Args) {}
+
     description() {
         return 'install project dependencies';
     }
 
     @logErrors
     async execute() {
-        const installCommand = process.env.CI ? 'ci' : 'i';
-        const npmArguments = [installCommand, '--no-audit', '--legacy-peer-deps'];
-        log.info(`startup cli v${getStartupVersion()}`);
-        log.info(`Running npm ${npmArguments.join(' ')} ...`);
-        await execa('npm', npmArguments, { stdio: 'inherit' });
+        /**
+         * Note, if these are changed, update bootstrap.js to match
+         * @see {@link file://./../../../../../bootstrap.js}
+         */
+        const npmArguments = [
+            process.env.CI ? 'ci' : 'i',
+            '--audit=false',
+            '--fund=false',
+            '--legacy-peer-deps',
+            ...(this.args?.fix ? ['--package-lock-only', '--prefer-dedupe'] : []),
+        ].join(' ');
+
+        if (!this.args?.quiet) {
+            log.info(`startup cli v${getStartupVersion()}`);
+            log.info(`Running npm ${npmArguments} ...`);
+        }
+
+        execSync(`npm ${npmArguments}`, { stdio: 'inherit' });
+
+        return Promise.resolve(); // stops "async method has no 'await' expression" lint error
     }
 }

package/src/cli/commands/lint.ts

@@ -26,7 +26,9 @@ interface Args {
 }
 
 export class Lint implements Command {
-    paths: string[];
+    readonly greedy = true;
+
+    private readonly paths: string[];
 
     constructor(private args: Args) {
         this.paths = [...args._];
@@ -44,25 +46,22 @@ export class Lint implements Command {
 
     @logErrors
     private async eslint() {
-        const { fix, ignore, parallel, scope } = this.args;
-        const { paths } = this;
-
-        const useESLint = !parallel && !scope?.length && !ignore?.length;
-        if (this.paths.length || useESLint) {
-            log.info('Running eslint...');
-            await eslint({ fix, paths });
+        if (this.useParallelESLint()) {
+            const { fix, ignore, scope } = this.args;
+            const packages = getPackages({ scope, ignore });
+            const args = fix ? ['--fix'] : [];
+
+            await lernaExec({
+                'cmd': 'startup eslint',
+                'scope': packages.map(({ name }) => name),
+                'bail': false,
+                '--': args,
+            });
             return;
         }
 
-        const packages = getPackages({ scope, ignore });
-        const args = fix ? ['--fix'] : [];
-
-        await lernaExec({
-            'cmd': 'startup eslint',
-            'scope': packages.map(({ name }) => name),
-            'bail': false,
-            '--': args,
-        });
+        log.info('Running eslint...');
+        await eslint({ fix: this.args.fix, paths: this.paths });
     }
 
     @logErrors
@@ -122,6 +121,12 @@ export class Lint implements Command {
             stream: true,
         });
     }
+
+    private useParallelESLint() {
+        const { parallel, scope, ignore } = this.args;
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        return !this.paths.length && (parallel || scope?.length || ignore?.length);
+    }
 }
 
 function pathUniJoin(...chunks: string[]) {

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

@@ -80,11 +80,7 @@ export class MFEPackagePublish implements Command {
 
         await npmPackageSet('version', data.version);
         await npmPackageSet('publishConfig.registry', data.registry);
-
-        if (!packageJson.files) {
-            await npmPackageSet('files[0]', 'dist');
-            await npmPackageSet('files[1]', 'package.json');
-        }
+        await this.setPackageFiles(packageJson);
 
         await npmPublish({ dry: data.dry, tag: data.tag || data.fallbackTag });
 
@@ -129,6 +125,27 @@ export class MFEPackagePublish implements Command {
         };
     }
 
+    private async setPackageFiles({ files: inputFiles }: { files?: string[] }) {
+        let outputFiles = ['dist/bundle', 'dist/metadata.json', 'package.json'];
+
+        if (inputFiles?.length) {
+            const index = inputFiles.findIndex(file => file === 'dist');
+            if (index < 0) {
+                return;
+            }
+            outputFiles = [
+                ...inputFiles.slice(0, index),
+                ...outputFiles.filter(file => file.startsWith('dist')),
+                ...inputFiles.slice(index + 1),
+            ];
+        }
+
+        for (let i = 0, n = outputFiles.length; i < n; i++) {
+            // eslint-disable-next-line no-await-in-loop
+            await npmPackageSet(`files[${i}]`, outputFiles[i]);
+        }
+    }
+
     private validateMetadata(version: string) {
         const { destination: outDir } = getFolders();
 

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

@@ -1,10 +1,4 @@
-import {
-    getPackages,
-    isWebComponent,
-    logErrors,
-    PackageType,
-    splitPackagesByType,
-} from '../../utils';
+import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
 import { ArgsPackageClean } from './mfe-package-clean';
 import { ArgsPackagePublish } from './mfe-package-publish';
 import { Command } from './types';
@@ -25,16 +19,9 @@ export class MFEPublish implements Command {
 
     @logErrors
     async execute() {
-        let packages = splitPackagesByType(getPackages())[PackageType.Webpack] ?? [];
-        packages = packages.filter(p => isWebComponent(p.location));
-
-        if (this.args.scope) {
-            packages = packages.filter(p =>
-                Array.isArray(this.args.scope)
-                    ? this.args.scope.includes(p.name)
-                    : this.args.scope === p.name
-            );
-        }
+        const packages = getPackages({ scope: this.args.scope, type: PackageType.Webpack }).filter(
+            ({ location }) => isWebComponent(location)
+        );
 
         if (!packages.length) {
             throw new Error('no packages found for publication');
@@ -43,7 +30,7 @@ export class MFEPublish implements Command {
         const isClean = !!this.args.clean;
         await lernaExec({
             'cmd': `startup mfe-package-${isClean ? 'clean' : 'publish'}`,
-            'concurrency': this.args.concurrency ?? 1,
+            'parallel': this.args.concurrency ?? 1,
             'scope': packages.map(({ name }) => name),
             'stream': true,
             '--': isClean ? this.getCleanOptions() : this.getPublishOptions(),

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

@@ -1,9 +1,10 @@
-import { isBundle, logErrors } from '../../utils';
-import { assetsCopy, assetsCopyWatch, stylesCopy, stylesCopyWatch, tcm, tcmWatch } from '../utils';
-import { Command } from '.';
+import { logErrors } from '../../utils';
+import { copyFiles, tcm } from '../utils';
+import { Command } from './types';
 
 interface Args {
-    watch?: boolean;
+    'watch'?: boolean;
+    'copy-files'?: boolean;
 }
 
 export class PreparePackage implements Command {
@@ -15,13 +16,8 @@ export class PreparePackage implements Command {
 
     @logErrors
     async execute() {
-        if (!this.args.watch) {
-            await Promise.all([...(!isBundle() ? [assetsCopy(), stylesCopy()] : []), tcm()]);
-        } else {
-            await Promise.all([
-                ...(!isBundle() ? [assetsCopyWatch(), stylesCopyWatch()] : []),
-                tcmWatch(),
-            ]);
-        }
+        await (this.args['copy-files']
+            ? copyFiles({ watch: this.args.watch })
+            : tcm({ watch: this.args.watch }));
     }
 }

package/src/cli/commands/review/__mocks__/expect-calls.ts

@@ -0,0 +1,48 @@
+/**
+ * Asserts that a sequence of mock function calls occurred in the specified order,
+ * with the specified arguments for each call.
+ *
+ * Each argument to this function should be either:
+ *   - a mock function (jest.Mock), or
+ *   - an array where the first element is a mock function and the rest are the expected arguments for that call.
+ *
+ * For each call, this function checks:
+ *   - The mock was called with the expected arguments (if provided).
+ *   - The call order is strictly increasing (i.e., each call happened after the previous one).
+ *
+ * @example
+ *   expectCalls(
+ *     [mockA, 1, 2],
+ *     [mockB, 'foo'],
+ *     mockC
+ *   );
+ *
+ * @param {...any[]} calls - Sequence of [mockFn, ...args] or mockFn to check call order and arguments.
+ */
+
+export function expectCalls(...calls: any[]) {
+    const numCalls: Map<jest.Mock, number> = new Map();
+
+    for (let i = 0, n = calls.length; i < n; i++) {
+        const [next, ...args] = getCall(calls[i]);
+        const callIndex = numCalls.get(next) ?? 0;
+
+        if (args.length) {
+            expect(next).toHaveBeenNthCalledWith(callIndex + 1, ...args);
+        }
+
+        if (i > 0) {
+            const [prev] = getCall(calls[i - 1]);
+            const prevCallIndex = numCalls.get(prev)! - 1;
+            expect(next.mock.invocationCallOrder[callIndex]).toBeGreaterThan(
+                prev.mock.invocationCallOrder[prevCallIndex]
+            );
+        }
+
+        numCalls.set(next, callIndex + 1);
+    }
+}
+
+function getCall(call: any) {
+    return (Array.isArray(call) ? call : [call]) as [jest.Mock, ...any];
+}

package/src/cli/commands/review/__mocks__/index.ts

@@ -0,0 +1 @@
+export * from './expect-calls';