@servicetitan/startup 38.0.0 → 38.1.0

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

@@ -83,6 +83,14 @@ describe(`[startup] ${MfeCheck.name}`, () => {
         });
     }
 
+    function itReportsCompatibleLightBundle() {
+        test('outputs human-readable compatible message', async () => {
+            await subject();
+
+            expect(utils.log.info).toHaveBeenCalledWith('Compatible: light bundle can be used');
+        });
+    }
+
     test('allows running from global location', () => {
         expect(entry.allowRunFromGlobal).toBe(true);
     });
@@ -97,11 +105,7 @@ describe(`[startup] ${MfeCheck.name}`, () => {
             });
         });
 
-        test('outputs human-readable compatible message', async () => {
-            await subject();
-
-            expect(utils.log.info).toHaveBeenCalledWith('Compatible: light bundle can be used');
-        });
+        itReportsCompatibleLightBundle();
 
         test('does not set exit code', async () => {
             await subject();
@@ -131,6 +135,23 @@ describe(`[startup] ${MfeCheck.name}`, () => {
                 });
             });
         });
+
+        describe('when host enables expose-shared-dependencies at the top level of cli', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    '/path/to/host/package.json': JSON.stringify({
+                        name: 'host-app',
+                        dependencies: mockMetadata.dependencies,
+                        cli: {
+                            'expose-shared-dependencies': true,
+                            'shared-dependencies': mockMetadata.sharedDependencies,
+                        },
+                    }),
+                });
+            });
+
+            itReportsCompatibleLightBundle();
+        });
     });
 
     describe('when incompatible', () => {

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

@@ -1,9 +1,10 @@
-import { log } from '../../../utils';
+import { exitWhenParentExits, log } from '../../../utils';
 import { SwcCompilePackage, TscCompile, TscCompilePackage } from '../../tasks';
 import { RunTask } from '../run-task';
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
+    exitWhenParentExits: jest.fn(),
     log: { error: jest.fn(), text: jest.fn() },
 }));
 jest.mock('../../tasks/swc-compile-package');
@@ -34,9 +35,27 @@ describe(`[startup] ${RunTask.name}`, () => {
 
                 expect(jest.mocked(task).mock.instances[0].execute).toHaveBeenCalled();
             });
+
+            test(`watches ${task.name} for the parent process to exit`, async () => {
+                await subject();
+
+                expect(jest.mocked(task).mock.instances[0].watchForParentExit).toHaveBeenCalled();
+            });
         })
     );
 
+    describe('watchForParentExit', () => {
+        beforeEach(() => (args = {}));
+
+        const subject = () => new RunTask(args).watchForParentExit();
+
+        test('does not watch for the parent process to exit', () => {
+            subject();
+
+            expect(exitWhenParentExits).not.toHaveBeenCalled();
+        });
+    });
+
     describe('with empty args', () => {
         beforeEach(() => (args = {}));
 

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

@@ -1,5 +1,5 @@
 import { createPackage } from '../../../__mocks__';
-import { Package, PackageType, getPackages, log } from '../../../utils';
+import { Package, PackageType, getConfiguration, getPackages, log } from '../../../utils';
 import { compile, lernaExec, typeCheck, watchStdout } from '../../utils';
 import { entry } from '../registry/start';
 import { Start } from '../start';
@@ -38,6 +38,7 @@ describe(`[startup] ${Start.name}`, () => {
         args = {};
         packages = [];
         jest.clearAllMocks();
+        jest.mocked(getConfiguration).mockReturnValue({});
         jest.mocked(getPackages).mockImplementation(() => packages);
         jest.mocked(watchStdout).mockImplementation((_process, _indicator, handler) => {
             handler(packages.length);
@@ -106,6 +107,12 @@ describe(`[startup] ${Start.name}`, () => {
         expect(entry.greedy).toBe(true);
     });
 
+    test('sets process.env.STARTUP_PARENT_PID', async () => {
+        await subject();
+
+        expect(process.env.STARTUP_PARENT_PID).toBe(String(process.pid));
+    });
+
     describe('with TSC package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
 
@@ -121,7 +128,7 @@ describe(`[startup] ${Start.name}`, () => {
         });
     });
 
-    describe('with Webpack package', () => {
+    describe('with bundle package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.Bundle })));
 
         itPreparesThePackages();
@@ -132,11 +139,11 @@ describe(`[startup] ${Start.name}`, () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
-                'cmd': 'startup bundle-webpack',
+                'cmd': 'startup bundle-package',
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--exposed-dependencies', '--use-watch-config'],
+                '--': ['--exposed-dependencies', '--use-watch-config', '--bundler webpack'],
             });
         });
 
@@ -144,24 +151,37 @@ describe(`[startup] ${Start.name}`, () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
-                'cmd': 'startup bundle-webpack',
+                'cmd': 'startup bundle-package',
                 'scope': packages.map(({ name }) => name),
                 'parallel': true,
                 'stream': true,
-                '--': ['--watch'],
+                '--': ['--watch', '--bundler webpack'],
             });
         });
 
-        describe('with --bundler=vite', () => {
-            beforeEach(() => (args.bundler = 'vite'));
-
-            test('bundles with Vite in watch mode', async () => {
+        function itBundlesWithVite() {
+            test('bundles with vite', async () => {
                 await subject();
 
                 expect(lernaExec).toHaveBeenCalledWith(
-                    expect.objectContaining({ cmd: 'startup bundle-vite' })
+                    expect.objectContaining({
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', '--bundler vite'],
+                    })
                 );
             });
+        }
+
+        describe('with --bundler=vite', () => {
+            beforeEach(() => (args.bundler = 'vite'));
+
+            itBundlesWithVite();
+        });
+
+        describe('with cli.bundler set to vite', () => {
+            beforeEach(() => jest.mocked(getConfiguration).mockReturnValue({ bundler: 'vite' }));
+
+            itBundlesWithVite();
         });
 
         describe('with "code-coverage"', () => {
@@ -172,8 +192,8 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--watch', '--code-coverage'],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', '--code-coverage', '--bundler webpack'],
                     })
                 );
             });
@@ -187,8 +207,8 @@ describe(`[startup] ${Start.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--watch', `--config "${args.config}"`],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--watch', `--config "${args.config}"`, '--bundler webpack'],
                     })
                 );
             });

package/src/cli/commands/build.ts

@@ -1,5 +1,5 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
-import { checkArgs, compile, getBundleCommand, lernaExec, ProcessTree, typeCheck } from '../utils';
+import { checkArgs, compile, lernaExec, ProcessTree, resolveBundler, typeCheck } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
 import type { entry } from './registry/build';
 import { Command } from './types';
@@ -38,7 +38,7 @@ export class Build 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);
@@ -77,11 +77,11 @@ export class Build extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
-                    '--': ['--exposed-dependencies'],
+                    '--': ['--exposed-dependencies', ...bundlerArg],
                 });
             },
             {
@@ -100,7 +100,7 @@ export class Build extends Command<typeof entry> {
                 }
 
                 return lernaExec({
-                    'cmd': bundleCmd,
+                    'cmd': 'startup bundle-package',
                     'scope': bundleScope,
                     'stream': true,
                     '--': [
@@ -108,6 +108,7 @@ export class Build extends Command<typeof entry> {
                         ...[this.args.codeCoverage ? '--code-coverage' : undefined],
                         ...[this.args.stat ? '--stat' : undefined],
                         ...[this.args.preview ? '--preview' : undefined],
+                        ...bundlerArg,
                     ].filter(item => !!item) as string[],
                 });
             },

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