@servicetitan/startup 37.0.2 → 38.1.0

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

@@ -0,0 +1,20 @@
+import { bundleConstants } from '../../core';
+import { getConfiguration } from '../../utils';
+import { entry } from './registry/bundle-package';
+import { Command } from './types';
+
+export class BundlePackage extends Command<typeof entry> {
+    async execute() {
+        // Local cli.bundler overrides project-wide default in this.args.bundler
+        const bundler =
+            getConfiguration().bundler ?? this.args.bundler ?? bundleConstants.defaultBundler;
+
+        if (bundler === 'vite') {
+            const { BundleVite } = await import('./bundle-vite');
+            await new BundleVite(this.args).execute();
+        } else {
+            const { BundleWebpack } = await import('./bundle-webpack');
+            await new BundleWebpack(this.args).execute();
+        }
+    }
+}

package/src/cli/commands/command.ts

@@ -0,0 +1,14 @@
+import { CommandName, exitWhenParentExits } from '../../utils';
+import { CommandEntry, InferArgs } from './types';
+
+export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
+    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
+
+    watchForParentExit(name: CommandName): void {
+        if ('watch' in this.args && this.args.watch === true) {
+            exitWhenParentExits(name);
+        }
+    }
+
+    abstract execute(): Promise<void>;
+}

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

@@ -2,7 +2,10 @@ import { getPackageManager } from '@servicetitan/install';
 import { getVersionMismatches } from '@servicetitan/startup-utils';
 import path from 'node:path';
 import { getExposedDependencies, Metadata } from '../../core';
+import type { Configuration } from '../../utils';
 import {
+    getSharedDependencies,
+    isExposeSharedDependencies,
     isWebComponent,
     loadSharedDependencies,
     log,
@@ -16,13 +19,7 @@ import { Command } from './types';
 interface HostPackageJSON {
     name: string;
     dependencies: Record<string, string>;
-    cli?: {
-        'web-component'?: boolean | string | object;
-        'webpack'?: {
-            'expose-shared-dependencies'?: boolean;
-            'shared-dependencies'?: Record<string, string>;
-        };
-    };
+    cli?: Configuration;
 }
 
 interface HostData extends HostPackageJSON {
@@ -82,7 +79,7 @@ export class MfeCheck extends Command<typeof entry> {
         const mfeSharedDependencies = mfeMetadata.sharedDependencies;
         const hostSharedDependencies = loadSharedDependencies(
             hostData.dependencies,
-            hostData.cli?.webpack?.['shared-dependencies']
+            getSharedDependencies(hostData)
         );
         const packageManager = getPackageManager();
         const workspacePackage = packageManager.getWorkspacePackage(hostData.location);
@@ -99,8 +96,7 @@ export class MfeCheck extends Command<typeof entry> {
         );
 
         const isHostMfe = isWebComponent(hostData);
-        const isSharedDependenciesEnabled =
-            hostData.cli?.webpack?.['expose-shared-dependencies'] === true;
+        const isSharedDependenciesEnabled = isExposeSharedDependencies(hostData);
         const compatible = !isHostMfe && !mismatchResult && isSharedDependenciesEnabled;
 
         return {

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

@@ -1,3 +1,4 @@
+import { bundleConstants } from '../../../core';
 import type { CommandEntry } from '../types';
 import { defineEntry } from './define-entry';
 
@@ -6,9 +7,9 @@ export const entry = defineEntry({
     greedy: true,
     options: {
         bundler: {
-            choices: ['vite', 'webpack'] as const,
+            choices: bundleConstants.bundlers,
             description: 'Bundler',
-            defaultDescription: 'webpack',
+            defaultDescription: bundleConstants.defaultBundler,
         },
         cdnPath: { string: true, description: 'Base url for application assets' },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },

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

@@ -0,0 +1,22 @@
+import { bundleConstants } from '../../../core';
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+/*
+ * Internal dispatcher invoked by `start`/`build` per package. Its options are the union of
+ * bundle-vite and bundle-webpack so it can forward them to whichever bundler it delegates to,
+ * plus the run's --bundler default.
+ */
+export const entry = defineEntry({
+    options: {
+        bundler: { choices: bundleConstants.bundlers, hidden: true },
+        codeCoverage: { boolean: true, hidden: true },
+        config: { string: true, hidden: true },
+        exposedDependencies: { boolean: true, hidden: true },
+        preview: { boolean: true, hidden: true },
+        printConfig: { boolean: true, hidden: true },
+        stat: { boolean: true, hidden: true },
+        useWatchConfig: { boolean: true, hidden: true },
+        watch: { boolean: true, hidden: true },
+    },
+} satisfies CommandEntry);

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

@@ -1,6 +1,7 @@
 import { CommandName } from '../../../utils';
 import { Command, CommandEntry, Newable } from '../types';
 import { entry as build } from './build';
+import { entry as bundlePackage } from './bundle-package';
 import { entry as bundleVite } from './bundle-vite';
 import { entry as bundleWebpack } from './bundle-webpack';
 import { entry as clean } from './clean';
@@ -64,6 +65,7 @@ function makeEntry<K extends CommandName, T extends CommandEntry>(
  */
 export const commandRegistry = {
     ...makeEntry(CommandName.build, build),
+    ...makeEntry(CommandName['bundle-package'], bundlePackage),
     ...makeEntry(CommandName['bundle-vite'], bundleVite),
     ...makeEntry(CommandName['bundle-webpack'], bundleWebpack),
     ...makeEntry(CommandName.clean, clean),

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

@@ -1,3 +1,4 @@
+import { bundleConstants } from '../../../core';
 import type { CommandEntry } from '../types';
 import { defineEntry } from './define-entry';
 
@@ -6,9 +7,9 @@ export const entry = defineEntry({
     greedy: true,
     options: {
         bundler: {
-            choices: ['vite', 'webpack'] as const,
+            choices: bundleConstants.bundlers,
             description: 'Bundler',
-            defaultDescription: 'webpack',
+            defaultDescription: bundleConstants.defaultBundler,
         },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
         config: { string: true, hidden: true, description: 'Use specified configuration' },

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

@@ -71,8 +71,6 @@ export interface ReviewConfiguration {
 }
 
 export type RuleConfiguration =
-    | Level
-    | [Level]
-    | [Level, { exclude?: string[] | Record<string, string[]> }];
+    Level | [Level] | [Level, { exclude?: string[] | Record<string, string[]> }];
 
 export type Level = 'warn' | 'error' | 'off';

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

@@ -12,15 +12,21 @@ const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
 };
 
 export class RunTask extends Command<typeof entry> {
+    watchForParentExit(): void {
+        // No-op: the task being run handles its own parent-exit watch.
+    }
+
     @logErrors
     async execute() {
         const { _ = [], taskName = this.args._?.[0], taskArgs = [], ...restOptions } = this.args;
 
         if (taskName && taskName in tasks) {
-            await new tasks[taskName]({
+            const task = new tasks[taskName]({
                 _: [..._, ...taskArgs],
                 ...restOptions,
-            }).execute();
+            });
+            task.watchForParentExit();
+            await task.execute();
             return;
         }
 

package/src/cli/commands/start.ts

@@ -2,10 +2,10 @@ import { getPackages, logErrors, PackageType } from '../../utils';
 import {
     checkArgs,
     compile,
-    getBundleCommand,
     lernaExec,
     pipeStdout,
     ProcessTree,
+    resolveBundler,
     typeCheck,
     watchStdout,
 } from '../utils';
@@ -28,6 +28,9 @@ export class Start extends Command<typeof entry> {
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
+        // Used by sub-processes to detect this process dying
+        process.env.STARTUP_PARENT_PID = String(process.pid);
+
         const useTsc = this.args.useTsc;
 
         const packages = getPackages({
@@ -43,7 +46,7 @@ export class Start extends Command<typeof entry> {
         const bundleScope = packages
             .filter(({ type }) => type === PackageType.Bundle)
             .map(({ name }) => name);
-        const bundleCmd = getBundleCommand(this.args);
+        const bundlerArg = [`--bundler ${resolveBundler(this.args)}`];
         const precompileScope = packages
             .filter(({ scripts }) => !!scripts?.precompile)
             .map(({ name }) => name);
@@ -126,11 +129,11 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
-                    '--': ['--exposed-dependencies', '--use-watch-config'],
+                    '--': ['--exposed-dependencies', '--use-watch-config', ...bundlerArg],
                 });
             },
             { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
@@ -142,7 +145,7 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
@@ -150,6 +153,7 @@ export class Start extends Command<typeof entry> {
                         '--watch',
                         this.args.config ? `--config "${this.args.config}"` : undefined,
                         this.args.codeCoverage ? '--code-coverage' : undefined,
+                        ...bundlerArg,
                     ].filter(item => !!item) as string[],
                 });
             },

package/src/cli/commands/types.ts

@@ -56,10 +56,6 @@ export interface CommandEntry {
     options?: CommandOptions;
 }
 
-export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
-    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
-
-    abstract execute(): Promise<void>;
-}
-
 export type Newable<T> = new (...args: any[]) => T;
+
+export { Command } from './command';

package/src/cli/index.ts

@@ -69,6 +69,9 @@ async function handleCommand(name: CommandName, argv: any) {
     const CommandClass = await entry.load();
     // eslint-disable-next-line @typescript-eslint/naming-convention
     const command = new CommandClass({ ...argv, _: argv._.slice(1) });
+
+    command.watchForParentExit(name);
+
     command.execute().catch(() => {
         process.exit(1);
     });

package/src/cli/tasks/__tests__/cli-task.test.ts

@@ -1,30 +1,17 @@
-import { log } from '../../../utils';
-import { pipeStdout, watchStdout } from '../../utils';
+import execa from 'execa';
+import { exitWhenParentExits, getFolders, log, readJsonSafe } from '../../../utils';
+import { killProcessTree, pipeStdout, watchStdout } from '../../utils';
 import { CliTask, Indicators } from '../cli-task';
 
-jest.mock('execa', () =>
-    jest.fn().mockReturnValue(
-        Object.assign(Promise.resolve(), {
-            stdout: {
-                on: jest.fn(),
-            },
-        })
-    )
-);
-
-jest.mock('../../utils', () => ({
-    pipeStdout: jest.fn(),
-    watchStdout: jest.fn(),
-}));
+jest.mock('execa', () => jest.fn());
+jest.mock('../../utils');
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
-    getFolders: jest.fn().mockReturnValue({
-        source: 'src',
-        destination: 'dist',
-    }),
+    exitWhenParentExits: jest.fn(),
+    getFolders: jest.fn(),
     log: { info: jest.fn() },
-    readJsonSafe: jest.fn().mockReturnValue({}),
+    readJsonSafe: jest.fn(),
 }));
 
 const taskName = 'cli-task-impl';
@@ -35,7 +22,11 @@ const indicators: Required<Indicators> = {
 };
 
 class CliTaskImpl extends CliTask {
-    constructor({ watch }: { watch: boolean }) {
+    constructor(
+        private command: string,
+        private args: string[],
+        { watch }: { watch: boolean }
+    ) {
         super({ name: taskName, global: false, watch, indicators });
     }
 
@@ -44,83 +35,204 @@ class CliTaskImpl extends CliTask {
     }
 
     async execute(): Promise<void> {
-        await this.runChildProcess('', []);
+        await this.runChildProcess(this.command, this.args);
     }
 }
 
-describe(`[startup] ${CliTask.name} task`, () => {
+describe(`[startup] ${CliTask.name}`, () => {
+    const command = 'foo';
+    const args = ['bar'];
+
     beforeEach(() => {
-        globalThis.performance.clearMarks();
-        globalThis.performance.clearMeasures();
         jest.clearAllMocks();
+        jest.mocked(readJsonSafe).mockReturnValue({});
     });
 
-    let watch = false;
-
-    const subject = () => new CliTaskImpl({ watch }).execute();
+    describe('watchForParentExit', () => {
+        const subject = () => new CliTaskImpl(command, args, { watch: true }).watchForParentExit();
 
-    test('logs completion message', async () => {
-        await subject();
+        test('does not watch for the parent process to exit', () => {
+            subject();
 
-        expect(log.info).toHaveBeenCalledWith(
-            expect.stringContaining(`${taskName} task completed in`)
-        );
+            expect(exitWhenParentExits).not.toHaveBeenCalled();
+        });
     });
 
-    describe('in watch mode', () => {
-        beforeEach(() => (watch = true));
+    describe('runChildProcess', () => {
+        const childPid = 4321;
+        let watch = false;
+
+        beforeEach(() => {
+            globalThis.performance.clearMarks();
+            globalThis.performance.clearMeasures();
+            jest.mocked(getFolders).mockReturnValue({ source: 'src', destination: 'dist' });
+            jest.mocked(execa).mockReturnValue(
+                Object.assign(Promise.resolve(), {
+                    pid: childPid,
+                    stdout: { on: jest.fn() },
+                }) as any
+            );
+        });
 
-        test('it calls pipeStdout', () => {
-            subject();
-            expect(pipeStdout).toHaveBeenCalled();
+        const subject = () => new CliTaskImpl(command, args, { watch }).execute();
+
+        test('runs command', async () => {
+            await subject();
+
+            expect(execa).toHaveBeenCalledWith(command, args, { stdio: 'inherit' });
         });
 
-        describe('onData handler', () => {
-            beforeEach(() => subject());
+        test('logs completion message', async () => {
+            await subject();
 
-            const onDataHandler = (data: string) => {
-                const handler = jest
-                    .mocked(watchStdout)
-                    .mock.calls.find(([_process, indicator]) => indicator === data)![2];
-                handler(1);
-            };
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringContaining(`${taskName} task completed in`)
+            );
+        });
+
+        describe('in watch mode', () => {
+            const originalPlatform = process.platform;
+            let onceSpy: jest.SpyInstance;
+            let killSpy: jest.SpyInstance;
+
+            beforeEach(() => {
+                watch = true;
+                onceSpy = jest.spyOn(process, 'once');
+                killSpy = jest.spyOn(process, 'kill').mockImplementation(jest.fn());
+            });
 
-            function itLogsInitialBuild(event: keyof Indicators) {
-                test('logs duration of initial build', () => {
-                    onDataHandler(indicators[event]);
+            afterEach(() => {
+                process.removeAllListeners('SIGINT');
+                process.removeAllListeners('SIGTERM');
+            });
 
-                    expect(log.info).toHaveBeenCalledWith(
-                        expect.stringContaining(`Initial ${taskName} task completed in`)
-                    );
+            function mockPlatform(platform: NodeJS.Platform) {
+                Object.defineProperty(process, 'platform', {
+                    value: platform,
+                    configurable: true,
                 });
             }
 
-            function itLogsSubsequentBuild(event: keyof Indicators) {
-                test('logs duration of subsequent build', () => {
-                    onDataHandler(indicators[event]!);
+            test('pipes stdout and conditionally runs command in own process', async () => {
+                await subject();
 
-                    expect(log.info).toHaveBeenCalledWith(
-                        expect.stringContaining(`Subsequent ${taskName} task completed in`)
-                    );
+                expect(execa).toHaveBeenCalledWith(command, args, {
+                    stdio: ['inherit', 'pipe', 'inherit'],
+                    detached: process.platform !== 'win32',
                 });
-            }
+            });
+
+            test('calls pipeStdout', () => {
+                subject();
 
-            itLogsInitialBuild('end');
+                expect(pipeStdout).toHaveBeenCalled();
+            });
+
+            test('watches for the parent process to exit', () => {
+                subject();
+
+                expect(exitWhenParentExits).toHaveBeenCalledWith(taskName, expect.any(Function));
+            });
+
+            describe('on POSIX', () => {
+                beforeEach(() => mockPlatform('darwin'));
+
+                afterEach(() => mockPlatform(originalPlatform));
+
+                describe.each<NodeJS.Signals>(['SIGINT', 'SIGTERM'])(
+                    'when the process receives %s',
+                    signal => {
+                        beforeEach(() => {
+                            subject();
+                            onceSpy.mock.calls.find(([registered]) => registered === signal)![1](
+                                signal
+                            );
+                        });
+
+                        test(`forwards ${signal} to the child process tree`, () => {
+                            expect(killProcessTree).toHaveBeenCalledWith(childPid, signal);
+                        });
+
+                        test(`re-raises ${signal}`, () => {
+                            expect(killSpy).toHaveBeenCalledWith(process.pid, signal);
+                        });
+                    }
+                );
+            });
+
+            describe('on Windows', () => {
+                beforeEach(() => mockPlatform('win32'));
+
+                afterEach(() => mockPlatform(originalPlatform));
+
+                test('does not intercept signals', () => {
+                    subject();
+
+                    expect(onceSpy).not.toHaveBeenCalled();
+                });
+            });
+
+            describe('when the parent process exits', () => {
+                const triggerParentExit = () =>
+                    jest.mocked(exitWhenParentExits).mock.calls[0][1]!();
 
-            describe('when subsequent build starts after initial build ends', () => {
                 beforeEach(() => {
-                    onDataHandler(indicators.end);
-                    onDataHandler(indicators.watchStart);
+                    subject();
+                    triggerParentExit();
                 });
 
-                itLogsSubsequentBuild('end');
-                itLogsSubsequentBuild('watchEnd');
+                test('kills the child process tree', () => {
+                    expect(killProcessTree).toHaveBeenCalledWith(childPid);
+                });
             });
 
-            describe('when subsequent build starts before initial build ends', () => {
-                beforeEach(() => onDataHandler(indicators.watchStart));
+            describe('onData handler', () => {
+                beforeEach(() => subject());
+
+                const onDataHandler = (data: string) => {
+                    const handler = jest
+                        .mocked(watchStdout)
+                        .mock.calls.find(([_process, indicator]) => indicator === data)![2];
+                    handler(1);
+                };
+
+                function itLogsInitialBuild(event: keyof Indicators) {
+                    test('logs duration of initial build', () => {
+                        onDataHandler(indicators[event]);
+
+                        expect(log.info).toHaveBeenCalledWith(
+                            expect.stringContaining(`Initial ${taskName} task completed in`)
+                        );
+                    });
+                }
+
+                function itLogsSubsequentBuild(event: keyof Indicators) {
+                    test('logs duration of subsequent build', () => {
+                        onDataHandler(indicators[event]!);
+
+                        expect(log.info).toHaveBeenCalledWith(
+                            expect.stringContaining(`Subsequent ${taskName} task completed in`)
+                        );
+                    });
+                }
+
+                itLogsInitialBuild('end');
+
+                describe('when subsequent build starts after initial build ends', () => {
+                    beforeEach(() => {
+                        onDataHandler(indicators.end);
+                        onDataHandler(indicators.watchStart);
+                    });
+
+                    itLogsSubsequentBuild('end');
+                    itLogsSubsequentBuild('watchEnd');
+                });
+
+                describe('when subsequent build starts before initial build ends', () => {
+                    beforeEach(() => onDataHandler(indicators.watchStart));
 
-                itLogsSubsequentBuild('watchEnd');
+                    itLogsSubsequentBuild('watchEnd');
+                });
             });
         });
     });