@servicetitan/startup 35.2.0-far-1776.0 → 35.2.0

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

@@ -0,0 +1,46 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        branch: {
+            string: true,
+            description: 'Branch name to associate with published version',
+            defaultDescription: 'current git branch',
+        },
+        build: {
+            string: true,
+            description: 'Package version',
+            defaultDescription: '<branch_name>.<commit_hash>',
+        },
+        dry: {
+            boolean: true,
+            description: 'Take no action and only log what would be published',
+        },
+        force: {
+            boolean: true,
+            description: 'Force publishing from an unrecognized branch',
+        },
+        registry: { string: true, hidden: true, description: 'Registry url' },
+        trackHistory: {
+            boolean: true,
+            description: 'Tag the previous release, to support rollbacks',
+            defaultDescription: 'true',
+            hidden: true,
+        },
+        tag: {
+            string: true,
+            description: 'Tag to assign to published version',
+        },
+        uploadSourcemaps: {
+            boolean: true,
+            description: 'Upload source maps to Datadog?',
+            defaultDescription: 'true',
+        },
+        purgeCache: {
+            boolean: true,
+            description: 'Purge unpkg cache after publishing?',
+            defaultDescription: 'true',
+        },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/mfe-package-rollback.ts

@@ -0,0 +1,26 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        dry: {
+            boolean: true,
+            description: 'Take no action and only log what would be rolled back',
+        },
+        registry: {
+            string: true,
+            hidden: true,
+            description: 'Registry url',
+        },
+        tag: {
+            string: true,
+            description: 'The tag to rollback to its previous version',
+            required: true,
+        },
+        purgeCache: {
+            boolean: true,
+            description: 'Purge unpkg cache after rolling back?',
+            defaultDescription: 'true',
+        },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,55 @@
+import type { CommandEntry, CommandOptions } from '../types';
+import { defineEntry } from './define-entry';
+import { entry as mfePackageClean } from './mfe-package-clean';
+import { entry as mfePackagePublish } from './mfe-package-publish';
+import { entry as mfePackageRollback } from './mfe-package-rollback';
+
+function publishOptions() {
+    return Object.entries(mfePackagePublish.options).reduce((result, [key, value]) => {
+        result[key] = { group: 'Publish Options:', ...value };
+        return result;
+    }, {} as CommandOptions);
+}
+
+function cleanOptions() {
+    // no-break space suffix prevents key collisions
+    return Object.entries(mfePackageClean.options).reduce((result, [key, value]) => {
+        result[`${key}\u00A0`] = { group: 'Clean Options:', ...value };
+        return result;
+    }, {} as CommandOptions);
+}
+
+function rollbackOptions() {
+    // double no-break space suffix prevents key collisions
+    return Object.entries(mfePackageRollback.options).reduce((result, [key, value]) => {
+        const optionProps = Object.fromEntries(
+            Object.entries(value).filter(([k]) => k !== 'required')
+        );
+        result[`${key}\u00A0\u00A0`] = { group: 'Rollback Options:', ...optionProps };
+        return result;
+    }, {} as CommandOptions);
+}
+
+export const entry = defineEntry({
+    description: 'Publish or unpublish MFE packages',
+    options: {
+        clean: { boolean: true, description: 'Unpublish old versions' },
+        concurrency: {
+            number: true,
+            description: 'Publish/unpublish the specified number of packages concurrently',
+            defaultDescription: '1',
+        },
+        rollback: {
+            boolean: true,
+            description: 'Rollback specified tag to the previous version',
+        },
+        scope: {
+            array: true,
+            string: true,
+            description: 'Publish/unpublish only the specified packages',
+        },
+        ...publishOptions(),
+        ...cleanOptions(),
+        ...rollbackOptions(),
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/mfe-purge-cache.ts

@@ -0,0 +1,27 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        host: {
+            string: true,
+            description: 'Host URL to send purge requests to',
+            demandOption: true,
+        },
+        packageName: {
+            string: true,
+            description: 'Package name to purge',
+            demandOption: true,
+        },
+        tag: {
+            string: true,
+            description: 'Package tag to purge',
+            demandOption: true,
+        },
+        token: {
+            string: true,
+            description: 'X-Purge-Token header value',
+            defaultDescription: 'process.env.UNPKG_PURGE_TOKEN',
+        },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,8 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        watch: { boolean: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/review.ts

@@ -0,0 +1,11 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Check project for configuration errors',
+    options: {
+        fix: { boolean: true, description: 'Fix detected problems' },
+        rule: { array: true, string: true, description: 'Limit checks to specified rule(s)' },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/start.ts

@@ -0,0 +1,14 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Run project in development mode',
+    greedy: true,
+    options: {
+        codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
+        config: { string: true, hidden: true, description: 'Use specified configuration' },
+        ignore: { array: true, string: true, description: 'Packages to skip' },
+        scope: { array: true, string: true, description: 'Packages to run and watch' },
+        useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/stylelint.ts

@@ -0,0 +1,12 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[paths...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        fix: { boolean: true, hidden: true },
+        paths: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,4 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({} satisfies CommandEntry);

package/src/cli/commands/registry/task.ts

@@ -0,0 +1,12 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '<taskName> [taskArgs...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        taskName: { string: true, hidden: true },
+        taskArgs: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/test-command.ts

@@ -0,0 +1,19 @@
+// NOTE: Not named test.ts to avoid being picked up by Jest as a test suite.
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Run tests',
+    greedy: true,
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[runnerArgs...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        runner: {
+            choices: ['jest', 'vitest'] as const,
+            description: 'Test runner',
+            defaultDescription: 'jest',
+        },
+        runnerArgs: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,14 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        dry: { boolean: true, description: 'Dry run mode' },
+        releaseVersion: {
+            string: true,
+            demandOption: true,
+            requiresArg: true,
+            description: 'Release version',
+        },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/review/__tests__/review.test.ts

@@ -5,6 +5,7 @@ import path from 'path';
 import terminalLink from 'terminal-link';
 import type { ProjectPackage } from '../../../../utils';
 import { findPackages, getReviewConfiguration, log } from '../../../../utils';
+import { entry } from '../../registry/review';
 import { expectCalls } from '../__mocks__';
 import { Review } from '../review';
 import { rules } from '../rules';
@@ -61,7 +62,7 @@ describe(`[startup] ${Review.name}`, () => {
     }
 
     test('allows running from global location', () => {
-        expect(Review.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     describe('when not run from workspace root', () => {

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

@@ -9,7 +9,8 @@ import {
     readJsonSafe,
     toArray,
 } from '../../../utils';
-import { Command, CommandOptions } from '../types';
+import type { entry } from '../registry/review';
+import { Command } from '../types';
 import { rules } from './rules';
 import {
     ErrorSeverity,
@@ -32,16 +33,7 @@ import {
 
 const collator = new Intl.Collator();
 
-const options = {
-    fix: { boolean: true, description: 'Fix detected problems' },
-    rule: { array: true, string: true, description: 'Limit checks to specified rule(s)' },
-} satisfies CommandOptions;
-
-export class Review extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Check project for configuration errors';
-    static readonly options = options;
-
+export class Review extends Command<typeof entry> {
     private readonly severityToLabel: Record<ErrorSeverity, string> = {
         [ErrorSeverity.warning]: chalk.yellow('warning'),
         [ErrorSeverity.error]: chalk.red('error'),

package/src/cli/commands/run-task.ts

@@ -2,13 +2,8 @@
 import { log, logErrors } from '../../utils';
 import { SwcCompilePackage, TscCompile, TscCompilePackage } from '../tasks';
 import { Task } from '../tasks/task';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    _: { description: '<taskName> [taskArgs...]', array: true, string: true },
-    taskName: { string: true, hidden: true },
-    taskArgs: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
+import type { entry } from './registry/task';
+import { Command } from './types';
 
 const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
     'tsc-compile-package': TscCompilePackage,
@@ -16,9 +11,7 @@ const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
     'tsc-compile': TscCompile,
 };
 
-export class RunTask extends Command<typeof options> {
-    static readonly options = options;
-
+export class RunTask extends Command<typeof entry> {
     @logErrors
     async execute() {
         const { _ = [], taskName = this.args._?.[0], taskArgs = [], ...restOptions } = this.args;

package/src/cli/commands/start.ts

@@ -8,15 +8,8 @@ import {
     typeCheck,
     watchStdout,
 } from '../utils';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
-    config: { string: true, hidden: true, description: 'Use specified configuration' },
-    ignore: { array: true, string: true, description: 'Packages to skip' },
-    scope: { array: true, string: true, description: 'Packages to run and watch' },
-    useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-} satisfies CommandOptions;
+import type { entry } from './registry/start';
+import { Command } from './types';
 
 enum StartProcesses {
     Precompile,
@@ -29,11 +22,7 @@ enum StartProcesses {
     BundlePackage,
 }
 
-export class Start extends Command<typeof options> {
-    static readonly description = 'Run project in development mode';
-    static readonly greedy = true;
-    static readonly options = options;
-
+export class Start extends Command<typeof entry> {
     @logErrors
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });

package/src/cli/commands/stylelint.ts

@@ -1,17 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { logErrors } from '../../utils';
 import { stylelint } from '../utils/stylelint';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    _: { description: '[paths...]', array: true, string: true },
-    fix: { boolean: true, hidden: true },
-    paths: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
-
-export class Stylelint extends Command<typeof options> {
-    static readonly options = options;
+import type { entry } from './registry/stylelint';
+import { Command } from './types';
 
+export class Stylelint extends Command<typeof entry> {
     @logErrors
     async execute() {
         await stylelint({ fix: this.args.fix, paths: this.paths });

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

@@ -2,6 +2,7 @@ import fs from 'fs';
 import { glob } from 'glob';
 import path from 'path';
 import { getFolders, isBundle, isLegacy, isStyleCheckDisabled, log, logErrors } from '../../utils';
+import type { entry } from './registry/styles-check';
 import { Command } from './types';
 
 const patterns = [
@@ -10,7 +11,7 @@ const patterns = [
     "@import '~@servicetitan/design-system/dist/system.min.css';",
 ];
 
-export class StylesCheck extends Command {
+export class StylesCheck extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (isLegacy() || !isBundle()) {

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

@@ -1,4 +1,5 @@
 import { getConfiguration } from '../../../../utils';
+import { entry } from '../../registry/test-command';
 import { Jest, Vitest } from '../runners';
 import { Tests } from '../tests';
 
@@ -23,7 +24,7 @@ describe(`[startup] ${Tests.name}`, () => {
     const subject = async () => new Tests(args).execute();
 
     test('command is greedy', () => {
-        expect(Tests.greedy).toBe(true);
+        expect(entry.greedy).toBe(true);
     });
 
     function itRunsJest() {

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

@@ -1,28 +1,15 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { Config } from '@jest/types';
 import { getConfiguration, logErrors } from '../../../utils';
-import { Command, CommandOptions } from '../types';
+import type { entry } from '../registry/test-command';
+import { Command } from '../types';
 import { Jest, Vitest } from './runners';
 
-const options = {
-    _: { description: '[runnerArgs...]', array: true, string: true },
-    runner: {
-        choices: ['jest', 'vitest'] as const,
-        description: 'Test runner',
-        defaultDescription: 'jest',
-    },
-    runnerArgs: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
-
 /**
  * This class is named "Tests" instead of "Test" because the corresponding
  * "test.ts" would be interpreted as a test file.
  */
-export class Tests extends Command<typeof options, Config.Argv> {
-    static readonly description = 'Run tests';
-    static readonly greedy = true;
-    static readonly options = options;
-
+export class Tests extends Command<typeof entry, Config.Argv> {
     @logErrors
     async execute() {
         const {

package/src/cli/commands/types.ts

@@ -49,13 +49,15 @@ export type InferArgs<T extends CommandOptions, U = unknown> = Expand<
 > &
     U;
 
-export abstract class Command<T extends CommandOptions = CommandOptions, U = unknown> {
-    static readonly allowRunFromGlobal?: boolean;
-    static readonly description?: string;
-    static readonly greedy?: boolean;
-    static readonly options?: CommandOptions;
+export interface CommandEntry {
+    description?: string;
+    greedy?: boolean;
+    allowRunFromGlobal?: boolean;
+    options?: CommandOptions;
+}
 
-    constructor(protected readonly args: InferArgs<T, U>) {}
+export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
+    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
 
     abstract execute(): Promise<void>;
 }

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

@@ -3,24 +3,14 @@ import { execSync } from 'child_process';
 import path from 'path';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { TSConfig } from '../utils';
-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;
+import type { entry } from './registry/upload-sourcemaps';
+import { Command } from './types';
 
 interface PackageJson {
     name: string;
 }
 
-export class UploadSourcemaps extends Command<typeof options> {
-    static readonly options = options;
+export class UploadSourcemaps extends Command<typeof entry> {
     #outDir?: string;
     #packageJson?: PackageJson;
 

package/src/cli/index.ts

@@ -5,7 +5,8 @@ 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 { commandRegistry } from './commands/registry';
+import type { CommandOptions } from './commands/types';
 import { checkStartupLocation, setNodeOptions } from './utils';
 
 const yargsInstance = yargs(hideBin(process.argv));
@@ -32,17 +33,15 @@ Object.values(CommandName)
     .parse();
 
 function addCommand(name: CommandName, y: typeof yargs) {
-    const klass = getCommand(name)! as typeof Command;
+    const entry = commandRegistry[name];
+
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    const { description, options: { _, ...options } = {} } = klass;
+    const { description, options: { _, ...options } = {} } = entry;
     const nameWithArgs = name + (_?.description ? ` ${_.description}` : '');
-    const groupedOptions = Object.entries(options).reduce(
-        (result, [key, value]) => {
-            result[kebabCase(key)] = { group: 'Command Options:', ...value };
-            return result;
-        },
-        {} as NonNullable<typeof klass.options>
-    );
+    const groupedOptions = Object.entries(options).reduce((result, [key, value]) => {
+        result[kebabCase(key)] = { group: 'Command Options:', ...value };
+        return result;
+    }, {} as CommandOptions);
     const handler = (argv: any) => handleCommand(name, argv);
     if (description) {
         y.command(nameWithArgs, description, groupedOptions, handler);
@@ -52,24 +51,26 @@ function addCommand(name: CommandName, y: typeof yargs) {
     return y;
 }
 
-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) });
+async function handleCommand(name: CommandName, argv: any) {
+    const entry = commandRegistry[name];
 
     checkNodeVersion();
-    checkStartupLocation(name, command);
+    checkStartupLocation(name, entry);
 
-    if (setNodeOptions(name, command)) {
+    if (setNodeOptions(name, entry)) {
         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);
-        });
+        return;
     }
+
+    const CommandClass = await entry.load();
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const command = new CommandClass({ ...argv, _: argv._.slice(1) });
+    command.execute().catch(() => {
+        process.exit(1);
+    });
 }
 
 function checkNodeVersion() {

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

@@ -1,5 +1,4 @@
 import { swcDir } from '@swc/cli';
-import debounce from 'debounce';
 import deepmerge from 'deepmerge';
 import { fs, vol } from 'memfs';
 import { getSwcCompilePackageConfiguration, log } from '../../../../utils';
@@ -7,7 +6,6 @@ import { TSConfig } from '../../../utils';
 import { getSwcOptions } from '../get-swc-options';
 import { SwcCompilePackage } from '../swc-compile-package';
 
-jest.mock('debounce', () => jest.fn());
 jest.mock('fs', () => fs);
 jest.mock('@swc/cli', () => ({
     swcDir: jest.fn(),
@@ -194,12 +192,7 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
     });
 
     describe('in watch mode', () => {
-        beforeEach(() => {
-            watch = true;
-            jest.mocked(debounce).mockImplementation((fn: Function) => {
-                return ((...args: any[]) => fn(...args)) as any;
-            });
-        });
+        beforeEach(() => (watch = true));
 
         test('calls swcDir with watch=true', () => {
             subject();

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

@@ -1,6 +1,5 @@
 import type { Options } from '@swc/cli';
 import { swcDir } from '@swc/cli';
-import debounce from 'debounce';
 import deepmerge from 'deepmerge';
 import { getFolders, getSwcCompilePackageConfiguration, getTsConfig, log } from '../../../utils';
 import { TSConfig } from '../../utils';
@@ -26,21 +25,12 @@ export class SwcCompilePackage extends Task {
         /* istanbul ignore next: debug only */
         log.debug('swc-compile-package:config', () => JSON.stringify(config, null, 2));
 
-        /*
-         * @swc/cli@0.5.0 doesn't implement "ignore" in watch mode so debounce
-         * noisy output. See https://servicetitan.atlassian.net/browse/FAR-1592
-         * and DEVELOPER_NOTES in file://./../../../package.json
-         */
-        const logSuccessResults = this.watch
-            ? debounce(this.logCompletionResults.bind(this), 200)
-            : this.logCompletionResults.bind(this);
-
         return new Promise((resolve, reject) => {
             swcDir({
                 ...config,
                 callbacks: {
                     onSuccess: (e: { duration: number }) => {
-                        logSuccessResults(this.taskTimer.add(e.duration));
+                        this.logCompletionResults(this.taskTimer.add(e.duration));
                         if (!this.watch) {
                             resolve();
                         }