@servicetitan/startup 29.0.0 → 30.0.0

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'],
+            });
+        });
+    });
+});

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

@@ -0,0 +1,156 @@
+import execa from 'execa';
+import { fs, vol } from 'memfs';
+import path from 'path';
+import { TscCompile } from '../tsc-compile';
+
+jest.mock('fs', () => fs);
+jest.mock('execa', () =>
+    jest.fn().mockReturnValue(
+        Object.assign(Promise.resolve(), {
+            stdout: {
+                on: jest.fn(),
+            },
+        })
+    )
+);
+
+describe(`[startup] ${TscCompile.name} task`, () => {
+    let watch = false;
+    let typeCheckOnly = false;
+    let scope: string[];
+    let ignore: string[];
+
+    beforeEach(() => {
+        vol.fromJSON({
+            'packages/foo/tsconfig.json': JSON.stringify({}),
+            'packages/foo/package.json': JSON.stringify({
+                name: 'foo',
+                cli: {
+                    webpack: false,
+                },
+                dependencies: {
+                    baz: '*',
+                },
+            }),
+            'packages/bar/tsconfig.json': JSON.stringify({}),
+            'packages/bar/package.json': JSON.stringify({
+                name: 'bar',
+                cli: {
+                    webpack: false,
+                },
+            }),
+            'packages/baz/tsconfig.json': JSON.stringify({}),
+            'packages/baz/package.json': JSON.stringify({
+                name: 'baz',
+                cli: {
+                    webpack: false,
+                },
+            }),
+            'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
+        });
+    });
+
+    afterEach(() => {
+        vol.reset();
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+        watch = false;
+        typeCheckOnly = false;
+        scope = [];
+        ignore = [];
+    });
+
+    function itRunsTsc(
+        caption: string,
+        {
+            watch = false,
+            typeCheckOnly = false,
+            tsConfigs,
+            stdio,
+        }: {
+            watch?: boolean;
+            typeCheckOnly?: boolean;
+            tsConfigs: string[];
+            stdio: string | string[];
+        }
+    ) {
+        test(`runs tsc ${caption}`, () => {
+            subject();
+
+            expect(execa).toHaveBeenCalledWith(
+                'tsc',
+                expect.arrayContaining(
+                    [
+                        '-b',
+                        watch ? '-w' : undefined,
+                        '--pretty',
+                        '--preserveWatchOutput',
+                        typeCheckOnly ? '--emitDeclarationOnly' : undefined,
+                        ...tsConfigs.map(config => expect.stringContaining(path.normalize(config))),
+                    ].filter(item => item !== undefined)
+                ),
+                {
+                    stdio,
+                }
+            );
+        });
+    }
+
+    const subject = () => new TscCompile({ watch, typeCheckOnly, scope, ignore }).execute();
+
+    itRunsTsc('', {
+        tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
+        stdio: 'inherit',
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        itRunsTsc('in watch mode', {
+            watch: true,
+            tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
+            stdio: ['inherit', 'pipe', 'inherit'],
+        });
+    });
+
+    describe('with "typeCheckOnly" mode', () => {
+        beforeEach(() => (typeCheckOnly = true));
+
+        itRunsTsc('in "typeCheckOnly" mode', {
+            typeCheckOnly: true,
+            tsConfigs: ['foo/tsconfig.json', 'bar/tsconfig.json'],
+            stdio: 'inherit',
+        });
+    });
+
+    describe('with "scope"', () => {
+        beforeEach(() => (scope = ['foo']));
+
+        itRunsTsc('with only specified package', {
+            tsConfigs: ['foo/tsconfig.json'],
+            stdio: 'inherit',
+        });
+    });
+
+    describe('with "ignore"', () => {
+        beforeEach(() => (ignore = ['foo']));
+
+        itRunsTsc('without specified package', {
+            tsConfigs: ['baz/tsconfig.json', 'bar/tsconfig.json'],
+            stdio: 'inherit',
+        });
+    });
+
+    describe('with both "scope" and "ignore"', () => {
+        beforeEach(() => {
+            scope = ['ba*'];
+            ignore = ['bar'];
+        });
+
+        itRunsTsc('with combined filters', {
+            tsConfigs: ['baz/tsconfig.json'],
+            stdio: 'inherit',
+        });
+    });
+});

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

@@ -0,0 +1,64 @@
+import execa from 'execa';
+import { Task, TaskParameters } from './task';
+
+export interface Indicators {
+    end: string;
+    watchStart: string;
+    watchEnd?: string;
+}
+
+export interface CliTaskParameters extends TaskParameters {
+    indicators: Indicators;
+}
+
+export abstract class CliTask extends Task {
+    private readonly indicators: Indicators;
+
+    constructor({ indicators, ...rest }: CliTaskParameters) {
+        super(rest);
+        this.indicators = indicators;
+    }
+
+    protected async runChildProcess(command: string, args: string[]) {
+        const childProcess = execa(
+            command,
+            args,
+            this.watch
+                ? {
+                      stdio: ['inherit', 'pipe', 'inherit'],
+                  }
+                : {
+                      stdio: 'inherit',
+                  }
+        );
+
+        if (!this.watch) {
+            try {
+                await childProcess;
+            } finally {
+                this.logCompletionResults(this.taskTimer.end());
+            }
+            return;
+        }
+
+        childProcess.stdout!.on('data', this.stdoutDataHandler);
+        await childProcess;
+    }
+
+    private readonly stdoutDataHandler = (data: Uint8Array | string) => {
+        process.stdout.write(data);
+
+        const dataStr = data.toString();
+
+        if (dataStr.includes(this.indicators.watchStart)) {
+            this.taskTimer.start();
+        }
+
+        if (
+            dataStr.includes(this.indicators.end) ||
+            (this.indicators.watchEnd && dataStr.includes(this.indicators.watchEnd))
+        ) {
+            this.logCompletionResults(this.taskTimer.end());
+        }
+    };
+}

package/src/cli/tasks/swc-cli.d.ts

@@ -0,0 +1,3 @@
+declare module '@swc/cli' {
+    function swcDir(options: any): void;
+}

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

@@ -0,0 +1,70 @@
+import { swcDir } from '@swc/cli';
+import { compilerOptions as baseCompilerOptions } from '../../../tsconfig/base.json';
+
+import { Task } from './task';
+import { getFolders, log, readJson } from '../../utils';
+
+interface Args {
+    [key: string]: unknown;
+    watch?: boolean;
+}
+
+export class SwcCompilePackage extends Task {
+    constructor({ watch }: Args) {
+        super({ name: 'swc-compile-package', global: false, watch });
+    }
+
+    description() {
+        return 'Compiles TypeScript files to JavaScript with SWC within package folder';
+    }
+
+    async execute(): Promise<void> {
+        const { source, destination } = getFolders();
+        const compilerOptions = readJson('tsconfig.json').compilerOptions ?? {};
+
+        return new Promise((resolve, reject) => {
+            swcDir({
+                cliOptions: {
+                    watch: this.watch,
+                    outDir: destination,
+                    stripLeadingPaths: true,
+                    extensions: ['.ts', '.tsx'],
+                    filenames: [source],
+                },
+                swcOptions: {
+                    jsc: {
+                        parser: {
+                            syntax: 'typescript',
+                            tsx: true,
+                            decorators: true,
+                        },
+                        target: baseCompilerOptions.target,
+                        transform: {
+                            legacyDecorator: baseCompilerOptions.experimentalDecorators,
+                            decoratorMetadata: baseCompilerOptions.emitDecoratorMetadata,
+                        },
+                    },
+                    sourceMaps: baseCompilerOptions.sourceMap,
+                    module: {
+                        type: compilerOptions.module === 'commonjs' ? 'commonjs' : 'es6',
+                    },
+                },
+                callbacks: {
+                    onSuccess: (e: { duration: number }) => {
+                        this.logCompletionResults(this.taskTimer.add(e.duration));
+                        if (!this.watch) {
+                            resolve();
+                        }
+                    },
+                    onFail: (e: { duration: number; reasons: Map<string, string> }) => {
+                        log.text([...e.reasons.values()][0]);
+                        this.logCompletionResults(this.taskTimer.add(e.duration));
+                        if (!this.watch) {
+                            reject(new Error('Compilation failed'));
+                        }
+                    },
+                },
+            });
+        });
+    }
+}