@servicetitan/startup 35.2.0-far-1776.1 → 35.3.0

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();
                         }

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

@@ -437,6 +437,23 @@ describe('[startup] Cli Utils', () => {
             );
         });
 
+        describe('with PORT environment variable', () => {
+            const port = '3456';
+
+            beforeEach(() => (process.env.PORT = port));
+
+            afterEach(() => delete process.env.PORT);
+
+            test('uses environment variable', async () => {
+                await subject();
+
+                expect(WebpackDevServer).toHaveBeenCalledWith(
+                    expect.objectContaining({ port: Number(port) }),
+                    expect.anything()
+                );
+            });
+        });
+
         describe('with "emitExposedDependencies"', () => {
             beforeEach(() => (options = { emitExposedDependencies: true }));
 

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

@@ -1,5 +1,5 @@
 import { log } from '../../../utils';
-import { Command } from '../../commands/types';
+import { CommandEntry } from '../../commands/types';
 import { checkStartupLocation } from '../check-startup-location';
 import { npmGetProjectRoot } from '../cli-npm';
 
@@ -9,24 +9,18 @@ jest.mock('../../../utils', () => ({
 }));
 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;
+        let entry: CommandEntry | undefined;
 
         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({});
+            entry = undefined;
         });
 
         afterAll(() => {
@@ -35,7 +29,7 @@ describe('[startup] Cli Utils', () => {
             }
         });
 
-        const subject = () => checkStartupLocation(commandName, mockCommand);
+        const subject = () => checkStartupLocation(commandName, entry);
 
         function itDoesNothing() {
             test('does nothing', () => {
@@ -67,13 +61,7 @@ describe('[startup] Cli Utils', () => {
             });
 
             describe('when command allows running from global location', () => {
-                beforeEach(() => {
-                    (mockCommand.constructor as any).allowRunFromGlobal = true;
-                });
-
-                afterEach(() => {
-                    delete (mockCommand.constructor as any).allowRunFromGlobal;
-                });
+                beforeEach(() => (entry = { allowRunFromGlobal: true }));
 
                 itDoesNothing();
             });

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/types';
+import { CommandEntry } from '../../commands/types';
 import { setNodeOptions } from '../set-node-options';
 
 jest.mock('os', () => ({
@@ -12,37 +12,23 @@ jest.mock('../../../utils', () => ({
     getConfigurationSafe: jest.fn(() => ({})),
 }));
 
-class MockCommand extends Command {
-    static get greedy() {
-        return true;
-    }
-
-    async execute() {
-        return Promise.resolve();
-    }
-}
-
 describe(`[startup] utils:${setNodeOptions.name}`, () => {
     const MB = 1024 * 1024;
     const DEFAULT_SIZE = 8192;
     const originalNodeOptions = process.env.NODE_OPTIONS;
     const maxOldSpaceSize = `--max_old_space_size=${DEFAULT_SIZE}`;
     const commandName: any = 'mock';
-    const command = new MockCommand({});
-    let greedy: boolean;
+    let entry: CommandEntry | undefined;
 
     beforeEach(() => {
-        greedy = true;
         delete process.env.NODE_OPTIONS;
         (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
-        jest.spyOn(command.constructor as typeof Command, 'greedy', 'get').mockImplementation(
-            () => greedy
-        );
+        entry = { greedy: true };
     });
 
     afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
 
-    const subject = () => setNodeOptions(commandName, command);
+    const subject = () => setNodeOptions(commandName, entry);
 
     test(`returns true and adds ${maxOldSpaceSize} to process.env.NODE_OPTIONS`, () => {
         expect(subject()).toBe(true);
@@ -51,7 +37,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
     });
 
     describe('when the command is not greedy', () => {
-        beforeEach(() => (greedy = false));
+        beforeEach(() => (entry = undefined));
 
         test('returns false and does not set NODE_OPTIONS', () => {
             expect(subject()).toBe(false);

package/src/cli/utils/bundle.ts

@@ -157,7 +157,7 @@ async function runServe({ devServer = {}, ...config }: Configuration) {
     const compiler = createWebpackCompiler(config);
     const host = devServer.host ?? 'localhost';
     const port = await getPortPromise({
-        port: Number(devServer.port) || 8080,
+        port: Number(process.env.PORT) || Number(devServer.port) || 8080,
         host,
     });
 

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

@@ -1,9 +1,11 @@
 import { CommandName, log } from '../../utils';
-import { Command } from '../commands';
+import { CommandEntry } from '../commands/types';
 import { npmGetProjectRoot } from './cli-npm';
 
-export function checkStartupLocation(commandName: CommandName, command: Command) {
-    const allowRunFromGlobal = (command.constructor as typeof Command).allowRunFromGlobal;
+export function checkStartupLocation(
+    commandName: CommandName,
+    { allowRunFromGlobal }: CommandEntry = {}
+) {
     if (allowRunFromGlobal || process.env.SKIP_STARTUP_LOCATION_CHECK) {
         return;
     }

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

@@ -1,6 +1,6 @@
 import os from 'os';
 import { CommandName, getConfigurationSafe } from '../../utils';
-import { Command } from '../commands';
+import { CommandEntry } from '../commands/types';
 
 const MAX_OLD_SPACE_SIZE_OPTION = 'max_old_space_size';
 const DEFAULT_MAX_OLD_SPACE_SIZE_MB = 8192;
@@ -8,10 +8,10 @@ const MIN_REMAINING_MEMORY_MB = 512;
 
 /**
  * Apply global defaults and custom CLI configuration to process.env.NODE_OPTIONS
- * @param command - the command being executed
+ * @param entry - the command's registry entry
  * @returns whether process's NODE_OPTIONS were changed
  */
-export function setNodeOptions(commandName: CommandName, command: Command) {
+export function setNodeOptions(commandName: CommandName, { greedy }: CommandEntry = {}) {
     const cliConfig = getConfigurationSafe();
     const cmdConfig = cliConfig[commandName];
 
@@ -25,7 +25,6 @@ export function setNodeOptions(commandName: CommandName, command: Command) {
         }, oldNodeOptions)
         .trim();
 
-    const greedy = (command.constructor as typeof Command).greedy;
     const newNodeOptions = ensureMaxOldSpaceSize(mergedOptions, greedy);
     if (newNodeOptions !== oldNodeOptions) {
         process.env.NODE_OPTIONS = newNodeOptions;

package/src/{cypress-config → cypress/config}/__tests__/webpack-config.test.ts

@@ -1,13 +1,13 @@
 import { fs, vol } from 'memfs';
-import { getSwcOptions } from '../../cli/tasks';
-import { TSConfig } from '../../cli/utils';
-import { getBaseTsConfig } from '../../utils';
-import { Overrides, rulesConfig } from '../../webpack/configs';
+import { getSwcOptions } from '../../../cli/tasks';
+import { TSConfig } from '../../../cli/utils';
+import { getBaseTsConfig } from '../../../utils';
+import { Overrides, rulesConfig } from '../../../webpack/configs';
 import { webpackConfig } from '../webpack-config';
 
 jest.mock('fs', () => fs);
-jest.mock('../../webpack/configs');
-jest.mock('../../cli/tasks');
+jest.mock('../../../webpack/configs');
+jest.mock('../../../cli/tasks');
 
 describe(`[startup/cypress-config] ${webpackConfig.name}`, () => {
     const mockRules: any[] = [

package/src/{cypress-config → cypress/config}/webpack-config.ts

@@ -1,10 +1,10 @@
 import { inspect } from 'node:util';
 import type { Configuration } from 'webpack';
 import merge from 'webpack-merge';
-import { getSwcOptions } from '../cli/tasks';
-import { TSConfig } from '../cli/utils';
-import { getTsConfigWithFallback, log } from '../utils';
-import { Context, Overrides, rulesConfig } from '../webpack/configs';
+import { getSwcOptions } from '../../cli/tasks';
+import { TSConfig } from '../../cli/utils';
+import { getTsConfigWithFallback, log } from '../../utils';
+import { Context, Overrides, rulesConfig } from '../../webpack/configs';
 
 export function webpackConfig(overrides?: Overrides): Configuration {
     const context = getContext();

package/src/cypress/types/index.ts

@@ -0,0 +1,11 @@
+// @ts-expect-error Module is only exported, not used in this project
+import type { mount } from 'cypress/react';
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Cypress {
+        interface Chainable {
+            mount: typeof mount;
+        }
+    }
+}