@servicetitan/startup 35.2.0-far-1776.1 → 35.2.0

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/utils/__tests__/get-package-data.test.ts

@@ -1,118 +1,47 @@
-import { fs, vol } from 'memfs';
 import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
+import { readJson } from '../read-json';
 
-jest.mock('fs', () => fs);
+jest.mock('../read-json', () => ({ readJson: jest.fn() }));
 
 describe(`[startup] Utils`, () => {
     describe(`${getPackageData.name}`, () => {
-        afterEach(() => vol.reset());
-
-        const subject = () => getPackageData();
-
-        describe('when root package.json with workspaces exists', () => {
-            beforeEach(() => {
-                vol.fromJSON({
-                    './package.json': JSON.stringify({
-                        name: 'packageName',
-                        dependencies: { foo: '1.1.0', baz: '3.0.0' },
-                    }),
-                    '../package.json': JSON.stringify({
-                        workspaces: ['packages/*'],
-                        dependencies: { foo: '1.0.0', bar: '2.0.0' },
-                    }),
-                });
-            });
-
-            test('returns merged dependencies (local overrides root)', () => {
-                expect(subject()).toEqual({
-                    name: 'packageName',
-                    dependencies: { foo: '1.1.0', bar: '2.0.0', baz: '3.0.0' },
-                });
-            });
-        });
-
-        describe('when no root package.json found', () => {
-            beforeEach(() => {
-                vol.fromJSON({
-                    './package.json': JSON.stringify({
-                        name: 'rootPackage',
-                        workspaces: ['packages/*'],
-                        dependencies: { foo: '1.0.0' },
-                    }),
-                });
-            });
-
-            test('returns only local dependencies', () => {
-                expect(subject()).toEqual({
-                    name: 'rootPackage',
-                    dependencies: { foo: '1.0.0' },
-                });
-            });
-        });
-
-        describe('when root has lerna.json with packages instead of workspaces', () => {
-            beforeEach(() => {
-                vol.fromJSON({
-                    './package.json': JSON.stringify({
-                        name: 'packageName',
-                        version: '2.0.0',
-                        dependencies: { foo: '1.0.0' },
-                    }),
-                    '../package.json': JSON.stringify({
-                        dependencies: { bar: '2.0.0' },
-                    }),
-                    '../lerna.json': JSON.stringify({
-                        packages: ['packages/*'],
-                    }),
-                });
-            });
-
-            test('returns dependencies from root discovered via lerna.json', () => {
-                expect(subject()).toEqual({
+        const packageJson = './package.json';
+        const ancestorPackageJson = '../../package.json';
+        let packages: Record<string, Record<string, any>>;
+
+        beforeEach(() => {
+            packages = {
+                [ancestorPackageJson]: { dependencies: { foo: '1.0.0', bar: '2.0.0' } },
+                [packageJson]: {
                     name: 'packageName',
-                    version: '2.0.0',
-                    dependencies: { bar: '2.0.0', foo: '1.0.0' },
-                });
-            });
+                    dependencies: { foo: '1.1.0', baz: '3.0.0' },
+                },
+            };
+            jest.mocked(readJson).mockImplementation(path => packages[path] ?? {});
         });
 
-        describe('when root has lerna.json but no package.json at root level', () => {
-            beforeEach(() => {
-                vol.fromJSON({
-                    './package.json': JSON.stringify({
-                        name: 'packageName',
-                        version: '3.0.0',
-                        dependencies: { foo: '1.0.0' },
-                    }),
-                    '../lerna.json': JSON.stringify({
-                        packages: ['packages/*'],
-                    }),
-                });
-            });
+        const subject = () => getPackageData();
 
-            test('returns only local dependencies', () => {
-                expect(subject()).toEqual({
-                    name: 'packageName',
-                    version: '3.0.0',
-                    dependencies: { foo: '1.0.0' },
-                });
+        test(`returns merged dependencies from ${packageJson} and ${ancestorPackageJson}`, () => {
+            expect(subject()).toEqual({
+                name: packages[packageJson].name,
+                dependencies: {
+                    ...packages[ancestorPackageJson].dependencies,
+                    ...packages[packageJson].dependencies,
+                },
             });
         });
 
-        describe('when package.json contains sharedDependencies', () => {
+        describe(`when ${packageJson} contains sharedDependencies`, () => {
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
-                vol.fromJSON({
-                    './package.json': JSON.stringify({
-                        name: 'packageName',
-                        dependencies: { foo: '1.0.0' },
-                        cli: { webpack: { 'shared-dependencies': sharedDependencies } },
-                    }),
+                Object.assign(packages[packageJson], {
+                    cli: { webpack: { 'shared-dependencies': sharedDependencies } },
                 });
             });
 
-            test('result contains sharedDependencies', () => {
+            test('returns sharedDependencies', () => {
                 expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
             });
         });

package/src/utils/find-up.ts

@@ -1,4 +1,4 @@
-import path from 'node:path';
+import path from 'path';
 
 export function findUp<T>(callback: (directory: string) => T | undefined) {
     let directory = path.resolve('./');

package/src/utils/get-package-data.ts

@@ -1,6 +1,4 @@
-import path from 'node:path';
-import { findUp } from './find-up';
-import { readJson, readJsonSafe } from './read-json';
+import { readJson } from './read-json';
 
 interface PackageData {
     name: string;
@@ -16,36 +14,13 @@ export function getPackageData(): PackageData {
         name: packageJson.name,
         version: packageJson.version,
         dependencies: {
-            ...findRootDependencies(),
+            ...readJson('../../package.json').dependencies,
             ...packageJson.dependencies,
         },
         sharedDependencies: packageJson.cli?.webpack?.['shared-dependencies'],
     };
 }
 
-function findRootDependencies() {
-    const cwd = path.resolve('./');
-    const root = findUp(directory => {
-        if (directory === cwd) {
-            return undefined;
-        }
-        const pkgPath = path.join(directory, 'package.json');
-        const pkg = readJsonSafe<{ workspaces?: string[]; dependencies?: Record<string, string> }>(
-            pkgPath
-        );
-        if (pkg?.workspaces) {
-            return pkg;
-        }
-
-        const lernaPath = path.join(directory, 'lerna.json');
-        if (readJsonSafe<{ packages?: string[] }>(lernaPath)?.packages) {
-            return pkg ?? {};
-        }
-    });
-
-    return root?.dependencies ?? {};
-}
-
 export function getPackageDependencyVersion(dependency: string, defaultVersion?: string) {
     try {
         const { version } = require(`${dependency}/package.json`);

package/src/utils/index.ts

@@ -1,4 +1,3 @@
-export * from './find-package-lock';
 export * from './find-packages';
 export * from './find-up';
 export * from './format-duration';
@@ -11,7 +10,6 @@ export * from './get-folders';
 export * from './get-jest-config';
 export * from './get-package-data';
 export * from './get-package-name';
-export * from './get-package-version';
 export * from './get-packages';
 export * from './get-startup-version';
 export * from './get-tsconfig';
@@ -23,5 +21,4 @@ export * from './omit';
 export * from './pick';
 export * from './prettify';
 export * from './read-json';
-export * from './resolve-package-lock-entry';
 export * from './to-array';

package/src/webpack/configs/cache-config.ts

@@ -1,5 +1,7 @@
+import fs from 'fs';
+import path from 'path';
 import { Configuration } from 'webpack';
-import { findPackageLock } from '../../utils';
+import { findUp } from '../../utils';
 import { Context, Overrides } from './types';
 
 type Config = Configuration['cache'];
@@ -26,3 +28,10 @@ export function cacheConfig(context: Context, _overrides: Overrides): Result {
         infrastructureLogging: { level: 'error' },
     };
 }
+
+function findPackageLock() {
+    return findUp(directory => {
+        const lockFile = path.resolve(path.join(directory), 'package-lock.json');
+        return fs.existsSync(lockFile) ? lockFile : undefined;
+    });
+}

package/src/webpack/configs/utils/__tests__/get-launchdarkly-sdk-version.test.ts

@@ -6,36 +6,24 @@ jest.mock('fs', () => fs);
 describe(`[startup] ${getLaunchDarklySdkVersion.name}`, () => {
     const launchDarklySdkVersion = '1.2.3';
 
-    afterEach(() => vol.reset());
-
     const subject = () => getLaunchDarklySdkVersion();
 
-    describe('when package is not in package-lock.json', () => {
-        beforeEach(() => {
-            vol.fromJSON({
-                './package-lock.json': JSON.stringify({ packages: {} }),
-            });
-        });
-
-        test('returns undefined', () => {
-            expect(subject()).toBeUndefined();
-        });
+    test('returns undefined', () => {
+        expect(subject()).toBeUndefined();
     });
 
-    describe('when package is in package-lock.json', () => {
+    describe('when package is present', () => {
         beforeEach(() => {
             vol.fromJSON({
-                './package-lock.json': JSON.stringify({
-                    packages: {
-                        'node_modules/launchdarkly-js-client-sdk': {
-                            version: launchDarklySdkVersion,
-                        },
-                    },
+                'node_modules/launchdarkly-js-client-sdk/package.json': JSON.stringify({
+                    version: launchDarklySdkVersion,
                 }),
             });
         });
 
-        test('returns version from package-lock.json', () => {
+        afterEach(() => vol.reset());
+
+        test('returns version from launchdarkly-js-client-sdk package', () => {
             expect(subject()).toEqual(launchDarklySdkVersion);
         });
     });

package/src/webpack/configs/utils/__tests__/get-web-components-version.test.ts

@@ -6,39 +6,19 @@ jest.mock('fs', () => fs);
 describe(`[startup] ${getWebComponentsVersion.name}`, () => {
     const webComponentsVersion = '1.2.3';
 
-    afterEach(() => vol.reset());
-
-    const subject = () => getWebComponentsVersion();
-
-    describe('when package is in package-lock.json', () => {
-        beforeEach(() => {
-            vol.fromJSON({
-                './package-lock.json': JSON.stringify({
-                    packages: {
-                        'node_modules/@servicetitan/web-components': {
-                            version: webComponentsVersion,
-                        },
-                    },
-                }),
-            });
-        });
-
-        test('returns version from package-lock.json', () => {
-            expect(subject()).toEqual(webComponentsVersion);
+    beforeEach(() => {
+        vol.fromJSON({
+            'packages/web-components/package.json': JSON.stringify({
+                version: webComponentsVersion,
+            }),
         });
     });
 
-    describe('when package is not in package-lock.json', () => {
-        beforeEach(() => {
-            vol.fromJSON({
-                './package-lock.json': JSON.stringify({ packages: {} }),
-            });
-        });
+    afterEach(() => vol.reset());
 
-        test('throws', () => {
-            expect(subject).toThrow(
-                'Unable to resolve @servicetitan/web-components version from package-lock.json'
-            );
-        });
+    const subject = () => getWebComponentsVersion();
+
+    test('returns version from @servicetitan/web-components package', () => {
+        expect(subject()).toEqual(webComponentsVersion);
     });
 });