@servicetitan/startup 28.5.0 → 30.0.0

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

@@ -0,0 +1,41 @@
+import { log, logErrors } from '../../utils';
+import { Command } from './types';
+import { SwcCompilePackage } from '../tasks/swc-compile-package';
+import { TscCompilePackage } from '../tasks/tsc-compile-package';
+import { TscCompile } from '../tasks/tsc-compile';
+import { Task } from '../tasks/task';
+
+interface Args {
+    [key: string]: unknown;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    _: string[];
+}
+
+const tasks: Record<string, new (args: Args) => Task> = {
+    'tsc-compile-package': TscCompilePackage,
+    'swc-compile-package': SwcCompilePackage,
+    'tsc-compile': TscCompile,
+};
+
+export class RunTask implements Command {
+    constructor(private readonly args: Args) {}
+
+    description() {
+        return undefined;
+    }
+
+    @logErrors
+    async execute() {
+        const taskName = this.args._[0];
+
+        if (taskName in tasks) {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const trimArgs = { ...this.args, _: this.args._.slice(1) };
+            await new tasks[taskName](trimArgs).execute();
+            return;
+        }
+
+        log.error(`Unknown task: "${taskName}"`);
+        log.text(`\nSupported tasks: "${Object.keys(tasks).join('", "')}"`);
+    }
+}

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 import execa from 'execa';
+import path from 'path';
 import { argv, Arguments } from 'yargs';
 import { CommandName, getStartupVersion, log } from '../utils';
 import { getCommand, getUserCommands } from './commands';
@@ -20,6 +21,7 @@ if (!Command) {
     process.exit(127);
 }
 
+checkNodeVersion();
 maybeCreateGitFolder(Command);
 
 if (setNodeOptions(name)) {
@@ -36,15 +38,25 @@ if (setNodeOptions(name)) {
 }
 
 function usage() {
-    write('\nUsage:\n');
+    log.text('\nUsage:');
 
     const commands = getUserCommands().filter(({ name }) => !!name);
     const maxNameLength = commands.reduce((result, { name }) => Math.max(result, name.length), 0);
     commands.forEach(({ name, description }) => {
-        write(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
+        log.text(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
     });
 }
 
-function write(text: string) {
-    return console.info(text); // eslint-disable-line no-console
+function checkNodeVersion() {
+    const nodeVersion = Number(process.versions.node.split('.')[0]);
+    if (nodeVersion % 2 === 0 || process.env.SKIP_NODE_VERSION_CHECK) {
+        return;
+    }
+
+    const { engines } = require(path.join(__dirname, '../../package.json'));
+    log.error(
+        `error: node v${nodeVersion} detected, only even-numbered LTS versions ${engines.node} are supported`
+    );
+    log.text('See https://nodejs.org/en/download for LTS versions');
+    process.exit(127);
 }

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

@@ -0,0 +1,115 @@
+import execa from 'execa';
+import { log } 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', () => ({
+    getFolders: jest.fn().mockReturnValue({
+        source: 'src',
+        destination: 'dist',
+    }),
+    log: { info: jest.fn() },
+    readJsonSafe: jest.fn().mockReturnValue({}),
+}));
+
+const taskName = 'cli-task-impl';
+const indicators: Required<Indicators> = {
+    end: 'Watching for file changes.',
+    watchStart: 'Starting incremental compilation.',
+    watchEnd: 'Watching changes.',
+};
+
+class CliTaskImpl extends CliTask {
+    constructor({ watch }: { watch: boolean }) {
+        super({ name: taskName, global: false, watch, indicators });
+    }
+
+    description() {
+        return '';
+    }
+
+    async execute(): Promise<void> {
+        await this.runChildProcess('', []);
+    }
+}
+
+describe(`[startup] ${CliTask.name} task`, () => {
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+    });
+
+    let watch = false;
+
+    const subject = () => new CliTaskImpl({ watch }).execute();
+
+    test('logs completion message', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringContaining(`${taskName} task completed in`)
+        );
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        describe('onData handler', () => {
+            beforeEach(() => subject());
+
+            const onDataHandler = (data: string) => {
+                jest.mocked(jest.mocked(execa).mock.results[0].value.stdout.on).mock.calls[0][1](
+                    data
+                );
+            };
+
+            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');
+            });
+        });
+    });
+});

package/src/cli/tasks/__tests__/swc-compile.test.ts

@@ -0,0 +1,192 @@
+import { swcDir } from '@swc/cli';
+import { log, readJson } from '../../../utils';
+import { SwcCompilePackage } from '../swc-compile-package';
+import { compilerOptions } from '../../../../tsconfig/base.json';
+
+jest.mock('@swc/cli', () => ({
+    swcDir: jest.fn(),
+}));
+
+jest.mock('../../../utils', () => ({
+    getFolders: jest.fn().mockReturnValue({
+        source: 'src',
+        destination: 'dist',
+    }),
+    log: { info: jest.fn(), text: jest.fn() },
+    readJsonSafe: jest.fn().mockReturnValue({}),
+    readJson: jest.fn().mockReturnValue({}),
+}));
+
+describe(`[startup] ${SwcCompilePackage.name} task`, () => {
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+
+    let watch = false;
+
+    const subject = () => new SwcCompilePackage({ watch }).execute();
+
+    const onSuccessHandlerParams = {
+        duration: 10,
+    };
+    const callOnSuccessHandler = (parameters: { duration: number }) => {
+        jest.mocked(swcDir).mock.calls[0][0].callbacks.onSuccess(parameters);
+    };
+
+    const onFailHandlerParams = {
+        duration: 10,
+        reasons: new Map([['index.js', 'Syntax error']]),
+    };
+    const callOnFailHandler = (parameters: { duration: number; reasons: Map<string, string> }) => {
+        jest.mocked(swcDir).mock.calls[0][0].callbacks.onFail(parameters);
+    };
+
+    test('calls swcDir', () => {
+        subject();
+
+        expect(swcDir).toHaveBeenCalledWith({
+            cliOptions: {
+                watch: false,
+                outDir: 'dist',
+                stripLeadingPaths: true,
+                extensions: ['.ts', '.tsx'],
+                filenames: ['src'],
+            },
+            swcOptions: {
+                jsc: {
+                    parser: {
+                        syntax: 'typescript',
+                        tsx: true,
+                        decorators: true,
+                    },
+                    target: compilerOptions.target,
+                    transform: {
+                        legacyDecorator: compilerOptions.experimentalDecorators,
+                        decoratorMetadata: compilerOptions.emitDecoratorMetadata,
+                    },
+                },
+                sourceMaps: compilerOptions.sourceMap,
+                module: {
+                    type: 'es6',
+                },
+            },
+            callbacks: {
+                onSuccess: expect.any(Function),
+                onFail: expect.any(Function),
+            },
+        });
+    });
+
+    describe('when package is commonjs', () => {
+        beforeEach(() => {
+            jest.mocked(readJson).mockReturnValueOnce({
+                compilerOptions: { module: 'commonjs' },
+            });
+        });
+
+        test('swc module type is commonjs', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    swcOptions: expect.objectContaining({
+                        module: { type: 'commonjs' },
+                    }),
+                })
+            );
+        });
+    });
+
+    test('onSuccess handler completes task and logs completion message', async () => {
+        const task = subject();
+
+        callOnSuccessHandler(onSuccessHandlerParams);
+
+        await task;
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringMatching(
+                `swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+            )
+        );
+    });
+
+    test('onFail handler fails task and logs completion message', async () => {
+        const task = subject();
+
+        callOnFailHandler(onFailHandlerParams);
+
+        await expect(task).rejects.toThrow('Compilation failed');
+
+        expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringMatching(
+                `swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+            )
+        );
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        test('calls swcDir with watch=true', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    cliOptions: expect.objectContaining({
+                        watch: true,
+                    }),
+                })
+            );
+        });
+
+        test('onSuccess handler logs completion messages', () => {
+            subject();
+
+            callOnSuccessHandler(onSuccessHandlerParams);
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Initial swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+                )
+            );
+
+            callOnSuccessHandler(onSuccessHandlerParams);
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Subsequent swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
+                )
+            );
+        });
+
+        test('onFail handler logs completion message', () => {
+            subject();
+
+            callOnFailHandler(onFailHandlerParams);
+
+            expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Initial swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+                )
+            );
+
+            callOnFailHandler(onFailHandlerParams);
+
+            expect(log.text).toHaveBeenCalledWith('Syntax error');
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching(
+                    `Subsequent swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
+                )
+            );
+        });
+    });
+});

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

@@ -0,0 +1,88 @@
+import { readJsonSafe } from '../../../utils';
+import { Task } from '../task';
+
+jest.mock('../../../utils', () => ({
+    readJsonSafe: jest.fn().mockReturnValue({}),
+}));
+
+class GlobalTask extends Task {
+    constructor() {
+        super({ name: 'GlobalTask', watch: false, global: true });
+    }
+
+    description() {
+        return '';
+    }
+
+    execute() {
+        return Promise.resolve();
+    }
+}
+
+class PackageTask extends Task {
+    constructor() {
+        super({ name: 'PackageTask', watch: false, global: false });
+    }
+
+    description() {
+        return '';
+    }
+
+    execute() {
+        return Promise.resolve();
+    }
+}
+
+describe(`[startup] ${Task.name} entity`, () => {
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+    });
+
+    describe('Global task', () => {
+        const subject = () => new GlobalTask();
+
+        test('runs from the workspace root directory', () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce({
+                workspaces: ['packages/*'],
+            });
+
+            expect(subject).not.toThrow();
+        });
+
+        test("doesn't run from the package directory", () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce({});
+
+            expect(subject).toThrow();
+        });
+
+        test("doesn't run from the arbitrary directory", () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce(undefined);
+
+            expect(subject).toThrow();
+        });
+    });
+
+    describe('Package task', () => {
+        const subject = () => new PackageTask();
+
+        test('runs from the package directory', () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce({});
+
+            expect(subject).not.toThrow();
+        });
+
+        test("doesn't run from the workspace root directory", () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce({ workspaces: ['packages/*'] });
+
+            expect(subject).toThrow();
+        });
+
+        test("doesn't run from arbitrary directory", () => {
+            jest.mocked(readJsonSafe).mockReturnValueOnce(undefined);
+
+            expect(subject).toThrow();
+        });
+    });
+});

package/src/cli/tasks/__tests__/tsc-compile-package.test.ts

@@ -0,0 +1,72 @@
+import execa from 'execa';
+import { TscCompilePackage } from '../tsc-compile-package';
+
+jest.mock('execa', () =>
+    jest.fn().mockReturnValue(
+        Object.assign(Promise.resolve(), {
+            stdout: {
+                on: jest.fn(),
+            },
+        })
+    )
+);
+
+const tsConfig = 'tsconfig.build.json';
+
+const tscOptions = [
+    '--pretty',
+    '--preserveWatchOutput',
+    '--noCheck',
+    '--composite',
+    'false',
+    '--declaration',
+    'false',
+    '--declarationMap',
+    'false',
+    '--tsBuildInfoFile',
+    'tsconfig.compile.tsbuildinfo',
+    '--project',
+    tsConfig,
+];
+
+jest.mock('../../../utils', () => ({
+    getFolders: jest.fn().mockReturnValue({
+        source: 'src',
+        destination: 'dist',
+    }),
+    log: { info: jest.fn() },
+    readJsonSafe: jest.fn().mockReturnValue({}),
+    getTsConfig: () => tsConfig,
+}));
+
+describe(`[startup] ${TscCompilePackage.name} task`, () => {
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+    });
+
+    let watch = false;
+
+    const subject = () => new TscCompilePackage({ watch }).execute();
+
+    test('calls execa', () => {
+        subject();
+
+        expect(execa).toHaveBeenCalledWith('tsc', tscOptions, {
+            stdio: 'inherit',
+        });
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        test('calls execa', () => {
+            subject();
+
+            expect(execa).toHaveBeenCalledWith('tsc', ['-w', ...tscOptions], {
+                stdio: ['inherit', 'pipe', 'inherit'],
+            });
+        });
+    });
+});