@servicetitan/startup 38.0.0 → 38.2.0

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

@@ -2,9 +2,11 @@
  * @jest-environment node
  */
 import { createPackage } from '../../../__mocks__';
-import { Package, PackageType, getPackages, log } from '../../../utils';
-import { compile, lernaExec, typeCheck } from '../../utils';
+import { Attributes } from '../../../telemetry';
+import { getConfiguration, getPackages, log, Package, PackageType } from '../../../utils';
+import { compile, lernaExec, ProcessTree, typeCheck } from '../../utils';
 import { Build } from '../build';
+import { Command } from '../command';
 import { kendoUILicense } from '../kendo-ui-license';
 import { entry } from '../registry/build';
 
@@ -25,14 +27,25 @@ jest.mock('../kendo-ui-license', () => ({
 }));
 
 describe(`[startup] ${Build.name}`, () => {
+    const commandProto = Command.prototype as unknown as {
+        recordStart: (command: string, attributes?: Attributes) => void;
+        recordEnd: (error?: unknown) => Promise<void>;
+    };
+
     let args: ConstructorParameters<typeof Build>[0];
     let packages: Package[];
+    let recordStart: jest.SpyInstance;
+    let recordEnd: jest.SpyInstance;
 
     beforeEach(() => {
         args = {};
         packages = [];
+        jest.restoreAllMocks();
         jest.clearAllMocks();
+        jest.mocked(getConfiguration).mockReturnValue({});
         jest.mocked(getPackages).mockImplementation(() => packages);
+        recordStart = jest.spyOn(commandProto, 'recordStart').mockImplementation(() => {});
+        recordEnd = jest.spyOn(commandProto, 'recordEnd').mockResolvedValue(undefined);
     });
 
     const subject = async () => new Build(args).execute();
@@ -105,7 +118,7 @@ describe(`[startup] ${Build.name}`, () => {
         });
     });
 
-    describe('with Webpack package', () => {
+    describe('with bundle package', () => {
         beforeEach(() => packages.push(createPackage({ type: PackageType.Bundle })));
 
         itPreparesThePackage();
@@ -122,11 +135,11 @@ describe(`[startup] ${Build.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'],
+                '--': ['--exposed-dependencies', '--bundler webpack'],
             });
         });
 
@@ -134,23 +147,36 @@ describe(`[startup] ${Build.name}`, () => {
             await subject();
 
             expect(lernaExec).toHaveBeenCalledWith({
-                'cmd': 'startup bundle-webpack',
+                'cmd': 'startup bundle-package',
                 'scope': packages.map(({ name }) => name),
                 'stream': true,
-                '--': [],
+                '--': ['--bundler webpack'],
             });
         });
 
-        describe('with --bundler=vite', () => {
-            beforeEach(() => (args.bundler = 'vite'));
-
-            test('bundles with Vite', 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',
+                        '--': ['--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"', () => {
@@ -161,8 +187,8 @@ describe(`[startup] ${Build.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--code-coverage'],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--code-coverage', '--bundler webpack'],
                     })
                 );
             });
@@ -176,8 +202,8 @@ describe(`[startup] ${Build.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--stat'],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--stat', '--bundler webpack'],
                     })
                 );
             });
@@ -191,8 +217,8 @@ describe(`[startup] ${Build.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': ['--preview'],
+                        'cmd': 'startup bundle-package',
+                        '--': ['--preview', '--bundler webpack'],
                     })
                 );
             });
@@ -206,8 +232,8 @@ describe(`[startup] ${Build.name}`, () => {
 
                 expect(lernaExec).toHaveBeenCalledWith(
                     expect.objectContaining({
-                        'cmd': 'startup bundle-webpack',
-                        '--': [`--config "${args.config}"`],
+                        'cmd': 'startup bundle-package',
+                        '--': [`--config "${args.config}"`, '--bundler webpack'],
                     })
                 );
             });
@@ -226,6 +252,41 @@ describe(`[startup] ${Build.name}`, () => {
         });
     });
 
+    describe('telemetry', () => {
+        beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
+
+        test('records the command start', async () => {
+            await subject();
+
+            expect(recordStart).toHaveBeenCalledWith('build', { bundler: expect.any(String) });
+        });
+
+        test('records the command completion', async () => {
+            await subject();
+
+            expect(recordEnd).toHaveBeenCalledWith();
+        });
+
+        describe('when the build fails', () => {
+            const error = new Error('bundle failed');
+
+            beforeEach(() => {
+                jest.spyOn(log, 'error').mockImplementation(jest.fn());
+                jest.spyOn(ProcessTree.prototype, 'run').mockRejectedValue(error);
+            });
+
+            test('records the failure', async () => {
+                await subject().catch(() => {});
+
+                expect(recordEnd).toHaveBeenCalledWith(error);
+            });
+
+            test('propagates the error', async () => {
+                await expect(subject()).rejects.toBe(error);
+            });
+        });
+    });
+
     describe('with "scope"', () => {
         beforeEach(() => (args.scope = ['foo']));
 

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

@@ -0,0 +1,65 @@
+import { getConfiguration } from '../../../utils';
+import { BundlePackage } from '../bundle-package';
+import { BundleVite } from '../bundle-vite';
+import { BundleWebpack } from '../bundle-webpack';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getConfiguration: jest.fn(() => ({})),
+}));
+jest.mock('../bundle-vite', () => ({ BundleVite: jest.fn(() => ({ execute: jest.fn() })) }));
+jest.mock('../bundle-webpack', () => ({ BundleWebpack: jest.fn(() => ({ execute: jest.fn() })) }));
+
+describe(`[startup] ${BundlePackage.name}`, () => {
+    let args: ConstructorParameters<typeof BundlePackage>[0];
+
+    const subject = () => new BundlePackage(args).execute();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = { exposedDependencies: true };
+        jest.mocked(getConfiguration).mockReturnValue({});
+    });
+
+    function itBundlesWithWebpack() {
+        test('bundles with webpack', async () => {
+            await subject();
+
+            expect(BundleWebpack).toHaveBeenCalledWith(args);
+        });
+    }
+
+    function itBundlesWithVite() {
+        test('bundles with vite', async () => {
+            await subject();
+
+            expect(BundleVite).toHaveBeenCalledWith(args);
+        });
+    }
+
+    itBundlesWithWebpack();
+
+    describe('with --bundler=vite', () => {
+        beforeEach(() => (args = { bundler: 'vite' }));
+
+        itBundlesWithVite();
+
+        describe('with cli.bundler set to webpack', () => {
+            beforeEach(() => jest.mocked(getConfiguration).mockReturnValue({ bundler: 'webpack' }));
+
+            itBundlesWithWebpack();
+        });
+    });
+
+    describe('with cli.bundler set to vite', () => {
+        beforeEach(() => jest.mocked(getConfiguration).mockReturnValue({ bundler: 'vite' }));
+
+        itBundlesWithVite();
+
+        describe('with --bundler=webpack', () => {
+            beforeEach(() => (args = { bundler: 'webpack' }));
+
+            itBundlesWithVite();
+        });
+    });
+});

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

@@ -0,0 +1,154 @@
+import { Attributes, telemetry } from '../../../telemetry';
+import { exitWhenParentExits } from '../../../utils';
+import { Command } from '../command';
+
+jest.mock('../../../telemetry', () => ({
+    telemetry: {
+        info: jest.fn(),
+        error: jest.fn(),
+        flush: jest.fn(() => Promise.resolve()),
+    },
+}));
+jest.mock('../../../utils', () => ({
+    exitWhenParentExits: jest.fn(),
+}));
+
+class MockCommand extends Command {
+    execute() {
+        return Promise.resolve();
+    }
+
+    recordStart(command: string, attributes?: Attributes): void {
+        return super.recordStart(command, attributes);
+    }
+
+    recordEnd(error?: unknown): Promise<void> {
+        return super.recordEnd(error);
+    }
+}
+
+describe(`[startup] ${Command.name} entity`, () => {
+    const name: any = 'mock-command';
+    const commandName = 'build';
+    const attributes: Attributes = { bundler: 'vite' };
+
+    let args: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = {};
+    });
+
+    describe('watchForParentExit', () => {
+        const subject = () => new MockCommand(args).watchForParentExit(name);
+
+        test('does not watch for the parent process to exit', () => {
+            subject();
+
+            expect(exitWhenParentExits).not.toHaveBeenCalled();
+        });
+
+        describe('with watch: true', () => {
+            beforeEach(() => (args = { watch: true }));
+
+            test('watches for the parent process to exit', () => {
+                subject();
+
+                expect(exitWhenParentExits).toHaveBeenCalledWith(name);
+            });
+        });
+    });
+
+    describe('recordStart', () => {
+        let command: MockCommand;
+
+        beforeEach(() => (command = new MockCommand(args)));
+
+        const subject = () => command.recordStart(commandName, attributes);
+
+        test('emits a command.started event with the attributes', () => {
+            subject();
+
+            expect(telemetry.info).toHaveBeenCalledWith(
+                'command.started',
+                expect.objectContaining({
+                    ...attributes,
+                    command: commandName,
+                    runId: expect.any(String),
+                })
+            );
+        });
+
+        describe('when a run is already active', () => {
+            beforeEach(() => command.recordStart(commandName, attributes));
+
+            test('does not start a second run', () => {
+                subject();
+
+                expect(telemetry.info).toHaveBeenCalledTimes(1);
+            });
+        });
+    });
+
+    describe('recordEnd', () => {
+        let error: unknown;
+        let command: MockCommand;
+
+        beforeEach(() => {
+            error = undefined;
+            command = new MockCommand(args);
+        });
+
+        const subject = () => command.recordEnd(error);
+
+        test('does not emit anything', async () => {
+            await subject();
+
+            expect(telemetry.info).not.toHaveBeenCalled();
+            expect(telemetry.error).not.toHaveBeenCalled();
+        });
+
+        describe('when called after recordStart', () => {
+            beforeEach(() => command.recordStart(commandName, attributes));
+
+            test('emits a command.finished event with a duration', async () => {
+                await subject();
+
+                expect(telemetry.info).toHaveBeenCalledWith(
+                    'command.finished',
+                    expect.objectContaining({
+                        ...attributes,
+                        command: commandName,
+                        runId: expect.any(String),
+                        duration: expect.any(Number),
+                    })
+                );
+            });
+
+            test('flushes pending telemetry', async () => {
+                await subject();
+
+                expect(telemetry.flush).toHaveBeenCalled();
+            });
+
+            describe('with an error', () => {
+                beforeEach(() => (error = new Error('boom')));
+
+                test('emits a command.finished error event', async () => {
+                    await subject();
+
+                    expect(telemetry.error).toHaveBeenCalledWith(
+                        'command.finished',
+                        error,
+                        expect.objectContaining({
+                            ...attributes,
+                            command: commandName,
+                            runId: expect.any(String),
+                            duration: expect.any(Number),
+                        })
+                    );
+                });
+            });
+        });
+    });
+});

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

@@ -40,7 +40,7 @@ describe(`[startup] ${Init.name}`, () => {
             force: true,
         });
         expect(fs.rmSync).toHaveBeenCalledWith(path.join(cwd, '.github', 'CODEOWNERS'));
-        expect(fs.rmSync).toHaveBeenCalledWith(path.join(cwd, 'package-lock.json'));
+        expect(fs.rmSync).not.toHaveBeenCalledWith(path.join(cwd, 'package-lock.json'));
     });
 
     describe('when cloning fails', () => {

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

@@ -1,83 +1,16 @@
-import { execSync } from 'child_process';
-import { getStartupVersion } from '../../../core';
-import { log } from '../../../utils';
 import { Install } from '../install';
 import { entry } from '../registry/install';
 
-jest.mock('child_process', () => ({ execSync: jest.fn() }));
-jest.mock('../../../core', () => ({
-    ...jest.requireActual('../../../core'),
-    getStartupVersion: jest.fn(),
-}));
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
-    log: { debug: jest.fn(), info: jest.fn() }, // suppress log output
-}));
-
 describe(`${Install.name}`, () => {
-    const startupVersion = '1.2.3';
-    let args: ConstructorParameters<typeof Install>[0];
-
-    beforeEach(() => {
-        args = {};
-        jest.clearAllMocks();
-        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
-    });
-
-    const subject = async () => new Install(args).execute();
+    const subject = async () => new Install({}).execute();
 
     test('allows running from global location', () => {
         expect(entry.allowRunFromGlobal).toBe(true);
     });
 
-    test('runs install', async () => {
-        await subject();
-
-        expect(execSync).toHaveBeenCalledWith(`npx --yes @servicetitan/install`, {
-            stdio: 'inherit',
-        });
-    });
-
-    const keys = ['fix', 'quiet', 'token'] satisfies (keyof typeof args)[];
-    describe.each(keys)('with --%s', option => {
-        beforeEach(() => (args[option] = true));
-
-        test(`runs install with --${option}`, async () => {
-            await subject();
-
-            expect(execSync).toHaveBeenCalledWith(
-                expect.stringContaining(`--${option}`),
-                expect.anything()
-            );
-        });
-    });
-
-    describe('with --no-token', () => {
-        beforeEach(() => (args.token = false));
-
-        test('runs install with --no-token', async () => {
-            await subject();
-
-            expect(execSync).toHaveBeenCalledWith(
-                expect.stringContaining('--no-token'),
-                expect.anything()
-            );
-        });
-    });
-
-    test('logs progress', async () => {
-        await subject();
-
-        expect(log.info).toHaveBeenCalledWith(`startup cli v${startupVersion}`);
-    });
-
-    describe('with --quiet', () => {
-        beforeEach(() => (args = { quiet: true }));
-
-        test('does not log progress', async () => {
-            await subject();
-
-            expect(log.info).not.toHaveBeenCalled();
-        });
+    test('throws guidance pointing to @servicetitan/install', async () => {
+        await expect(subject()).rejects.toThrow(
+            'The `startup install` command has been removed. Run `npx --yes @servicetitan/install` directly instead.'
+        );
     });
 });

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 = {}));