@servicetitan/startup 29.0.0 → 30.0.0

package/src/cli/tasks/task.ts

@@ -0,0 +1,112 @@
+import { log, readJsonSafe } from '../../utils';
+
+class TaskTimer {
+    private counter = 0;
+
+    private get currentMarkName() {
+        return `${this.name}[${this.counter}]`;
+    }
+
+    private get currentMarkList() {
+        return globalThis.performance.getEntriesByName(this.currentMarkName, 'mark');
+    }
+
+    constructor(private readonly name: string) {
+        this.start();
+    }
+
+    start() {
+        if (this.currentMarkList.length > 0) {
+            this.cancel();
+        }
+
+        globalThis.performance.mark(this.currentMarkName);
+    }
+
+    end() {
+        if (this.currentMarkList.length === 0) {
+            throw new Error(`There are no tasks in progress for ${this.currentMarkName}`);
+        }
+
+        const measure = globalThis.performance.measure(this.currentMarkName, this.currentMarkName);
+        return { measure, counter: this.counter++ };
+    }
+
+    cancel() {
+        if (this.currentMarkList.length === 0) {
+            throw new Error(`There are no tasks in progress for ${this.currentMarkName}`);
+        }
+
+        const measure = globalThis.performance.measure(this.currentMarkName, {
+            start: this.currentMarkName,
+            detail: {
+                status: 'cancelled',
+            },
+        });
+
+        return { measure, counter: this.counter++ };
+    }
+
+    add(duration: number) {
+        const measure = globalThis.performance.measure(this.currentMarkName, {
+            duration,
+            end: globalThis.performance.now(),
+        });
+        return { measure, counter: this.counter++ };
+    }
+}
+
+export interface TaskParameters {
+    name: string;
+    watch?: boolean;
+    global: boolean;
+}
+
+export abstract class Task {
+    protected readonly watch: boolean;
+    protected readonly taskTimer: TaskTimer;
+    private readonly name: string;
+    private readonly global: boolean;
+
+    constructor({ name, watch, global }: TaskParameters) {
+        this.name = name;
+        this.watch = !!watch;
+        this.global = global;
+        this.taskTimer = new TaskTimer(name);
+        this.checkRunLocation();
+    }
+
+    protected logCompletionResults({
+        measure,
+        counter,
+    }: {
+        measure: PerformanceMeasure;
+        counter: number;
+    }) {
+        const enumerator = counter === 0 ? 'Initial ' : 'Subsequent ';
+        log.info(
+            `${this.watch ? enumerator : ''}${this.name} task completed in ${this.formatDuration(measure.duration)}`
+        );
+    }
+
+    private formatDuration(duration: number) {
+        if (duration < 1000) {
+            return `${duration.toFixed(0)}ms`;
+        }
+        return `${(duration / 1000).toFixed(2)}s`;
+    }
+
+    private checkRunLocation() {
+        const packageJson = readJsonSafe('package.json');
+        if (!packageJson?.workspaces && this.global) {
+            throw new Error(`Task ${this.name} has to run inside the workspace root directory`);
+        }
+        if ((!packageJson || packageJson.workspaces) && !this.global) {
+            throw new Error(`Task ${this.name} has to run inside the package directory`);
+        }
+    }
+
+    abstract description(): string;
+
+    abstract execute(): Promise<void>;
+}

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

@@ -0,0 +1,47 @@
+import { CliTask } from './cli-task';
+import { getTsConfig } from '../../utils';
+interface Args {
+    [key: string]: unknown;
+    watch?: boolean;
+}
+
+export class TscCompilePackage extends CliTask {
+    constructor({ watch }: Args) {
+        super({
+            name: 'tsc-compile-package',
+            global: false,
+            indicators: {
+                end: 'Watching for file changes.',
+                watchStart: 'Starting incremental compilation.',
+            },
+            watch,
+        });
+    }
+
+    description() {
+        return 'Compiles TypeScript files to JavaScript with TSC within package folder';
+    }
+
+    async execute() {
+        const tsConfig = getTsConfig();
+        await this.runChildProcess(
+            'tsc',
+            [
+                this.watch ? '-w' : undefined,
+                '--pretty',
+                '--preserveWatchOutput',
+                '--noCheck',
+                '--composite',
+                'false',
+                '--declaration',
+                'false',
+                '--declarationMap',
+                'false',
+                '--tsBuildInfoFile',
+                'tsconfig.compile.tsbuildinfo',
+                '--project',
+                tsConfig,
+            ].filter(i => i !== undefined)
+        );
+    }
+}

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

@@ -0,0 +1,64 @@
+import {
+    getPackages,
+    getPackagesGraph,
+    getTsConfig,
+    Package,
+    PackageType,
+    splitPackagesByType,
+} from '../../utils';
+import { CliTask } from './cli-task';
+
+interface Args {
+    [key: string]: unknown;
+    ignore?: string | string[];
+    scope?: string | string[];
+    watch?: boolean;
+    typeCheckOnly?: boolean;
+}
+
+export class TscCompile extends CliTask {
+    constructor(private readonly args: Args) {
+        super({
+            name: 'tsc-compile',
+            watch: args.watch,
+            global: true,
+            indicators: {
+                end: 'Watching for file changes.',
+                watchStart: 'Starting incremental compilation.',
+            },
+        });
+    }
+
+    description() {
+        return 'Compiles one or more TypeScript projects with optional type checking';
+    }
+
+    async execute() {
+        const packages = splitPackagesByType(
+            getPackages({ scope: this.args.scope, ignore: this.args.ignore })
+        )[PackageType.TSC];
+        const tsConfigs = collapsePackages(packages).map(({ location }) => getTsConfig(location));
+        await this.runChildProcess(
+            'tsc',
+            [
+                '-b',
+                this.watch ? '-w' : undefined,
+                '--pretty',
+                '--preserveWatchOutput',
+                this.args.typeCheckOnly ? '--emitDeclarationOnly' : undefined,
+                ...tsConfigs,
+            ].filter(i => i !== undefined)
+        );
+    }
+}
+
+/**
+ * Exclude dependant packages as they will be built through project references
+ */
+function collapsePackages(packages: Package[]) {
+    const dependencies = new Set(
+        Object.values(getPackagesGraph({ scope: packages.map(({ name }) => name) })).flat()
+    );
+
+    return packages.filter(({ name }) => !dependencies.has(name));
+}

package/src/cli/utils/__tests__/assets-copy.test.ts

@@ -38,7 +38,7 @@ describe('[startup] Cli Utils (Assets)', () => {
         test('copies assets from source to destination in watch mode', async () => {
             try {
                 await subject();
-            } catch (error: any) {
+            } catch {
                 // ignore rejected promise that terminates watch()
             }
 

package/src/cli/utils/__tests__/bundle.test.ts

@@ -106,7 +106,7 @@ describe('[startup] Cli Utils', () => {
 
             test('returns errors', () => {
                 const toStringSpy = jest.spyOn(stats, 'toString');
-                expect(subject).rejects.toBe(stats.toString());
+                expect(subject).rejects.toThrow(stats.toString());
                 expect(toStringSpy).toHaveBeenCalledWith('errors-only');
             });
         });

package/src/cli/utils/__tests__/cli-os.test.ts

@@ -57,13 +57,13 @@ describe('[startup] Cli Utils (OS)', () => {
             beforeEach(() => (exitCode = 2));
 
             test('rejects promise', () => {
-                expect(subject('foo')).rejects.toBeUndefined();
+                expect(subject('foo')).rejects.toThrow(`command exited with code: ${exitCode}`);
             });
         });
 
         ['', [], ['']].forEach(command =>
             test(`rejects promise when called with ${JSON.stringify(command)}`, () => {
-                expect(subject(command)).rejects.toBeUndefined();
+                expect(subject(command)).rejects.toThrow('invalid command');
             })
         );
 

package/src/cli/utils/__tests__/eslint.test.ts

@@ -2,11 +2,12 @@ import { fs, vol } from 'memfs';
 import { ESLint } from 'eslint';
 
 import { eslint } from '../eslint';
+import { getDestinationFolders } from '../../../utils/get-destination-folders';
 
 jest.mock('fs', () => fs);
 jest.mock('eslint');
 jest.mock('../../../utils/get-destination-folders', () => ({
-    getDestinationFolders: () => [],
+    getDestinationFolders: jest.fn(),
 }));
 
 describe(`[startup] utils:${eslint.name}`, () => {
@@ -37,19 +38,30 @@ describe(`[startup] utils:${eslint.name}`, () => {
         eslintArgs = { paths: ['foo', 'bar'] };
         eslintResults = [mockResult];
         eslintErrors = [];
+        jest.mocked(getDestinationFolders).mockReturnValue([]);
     });
 
     const subject = async () => eslint(eslintArgs);
 
-    test('lints .ts and .tsx files', async () => {
+    test.each(['.vscode/', '**/.yalc/', '**/*.css.d.ts', '**/*.scss.d.ts', '**/*.less.d.ts'])(
+        'ignores %s',
+        async pattern => {
+            await subject();
+
+            const ignorePatterns = jest.mocked(ESLint).mock.calls[0][0]?.ignorePatterns;
+            expect(ignorePatterns).toContain(pattern);
+        }
+    );
+
+    test('ignores output folders', async () => {
+        const outputFolders = ['../foo/out/', 'dist/', 'packages/bar/out/', 'packages/foo/dist/'];
+
+        jest.mocked(getDestinationFolders).mockReturnValue(outputFolders);
+
         await subject();
 
-        expect(ESLint).toHaveBeenCalledWith(
-            expect.objectContaining({
-                extensions: ['.ts', '.tsx'],
-            })
-        );
-        expect(mockESLint.lintFiles).toHaveBeenCalledWith(eslintArgs.paths);
+        const ignorePatterns = jest.mocked(ESLint).mock.calls[0][0]?.ignorePatterns;
+        outputFolders.forEach(dir => expect(ignorePatterns).toContain(dir));
     });
 
     describe('when instructed to fix issues', () => {
@@ -58,6 +70,7 @@ describe(`[startup] utils:${eslint.name}`, () => {
         test('applies fixes', async () => {
             await subject();
 
+            expect(ESLint).toHaveBeenCalledWith(expect.objectContaining({ fix: true }));
             expect(ESLint.outputFixes).toHaveBeenCalledWith(eslintResults);
         });
     });
@@ -99,4 +112,20 @@ describe(`[startup] utils:${eslint.name}`, () => {
             expect(mockESLint.lintFiles).not.toHaveBeenCalled();
         });
     });
+
+    describe('with custom ESLint config', () => {
+        const eslintConfig: any = { foo: 'bar' };
+
+        const config = JSON.stringify({
+            cli: { lint: { eslint: { ...eslintConfig } } },
+        });
+
+        beforeEach(() => vol.fromJSON({ 'package.json': config }));
+
+        test('passes through custom config', async () => {
+            await subject();
+
+            expect(ESLint).toHaveBeenCalledWith(expect.objectContaining(eslintConfig));
+        });
+    });
 });

package/src/cli/utils/__tests__/styles-copy.test.ts

@@ -38,7 +38,7 @@ describe('[startup] Cli Utils (Styles)', () => {
         test('copies styles from source to destination in watch mode', async () => {
             try {
                 await subject();
-            } catch (error: any) {
+            } catch {
                 // ignore rejected promise that terminates watch()
             }
 

package/src/cli/utils/__tests__/tsc.test.ts

@@ -1,84 +1,63 @@
 import execa from 'execa';
-import { fs, vol } from 'memfs';
-import { Package, getPackagesGraph, getTsConfig } from '../../../utils';
-import { createPackage } from '../../../__mocks__';
+import { lernaExec } from '../lerna-exec';
 
 import { tsc, tscWatch } from '../tsc';
+import { createPackage } from '../../../__mocks__';
 
-jest.mock('fs', () => fs);
 jest.mock('execa', () => jest.fn());
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
-    log: { info: jest.fn(), debug: jest.fn() }, // suppress test output
-    getPackagesGraph: jest.fn(),
+jest.mock('../lerna-exec', () => ({
+    lernaExec: jest.fn(),
 }));
 
 describe('[startup] Cli Utils', () => {
-    let packages: Package[];
+    const packages = ['foo', 'bar'].map(name => createPackage({ name }));
 
     beforeEach(() => {
-        jest.resetAllMocks();
-        jest.mocked(getPackagesGraph).mockReturnValue({});
-        packages = [
-            createPackage({ name: 'foo', location: 'packages/foo' }),
-            createPackage({ name: 'bar', location: 'packages/bar' }),
-        ];
-        vol.fromJSON({
-            'packages/foo/tsconfig.json': JSON.stringify({}),
-            'packages/bar/tsconfig.json': JSON.stringify({}),
-        });
+        jest.clearAllMocks();
     });
 
-    afterEach(() => vol.reset());
+    function itRunsTscCompile(watch = false, typeCheckOnly = false) {
+        expect(execa).toHaveBeenCalledWith(
+            'startup',
+            [
+                'task',
+                'tsc-compile',
+                ...packages.map(({ name }) => `--scope=${name}`),
+                watch ? '--watch' : undefined,
+                typeCheckOnly ? '--type-check-only' : undefined,
+            ].filter(i => i !== undefined),
+            { stdio: 'inherit' }
+        );
+    }
+
+    function itRunsTscCompilePackage(watch = false) {
+        expect(lernaExec).toHaveBeenCalledWith({
+            cmd: 'startup task tsc-compile-package',
+            scope: packages.map(({ name }) => name),
+            parallel: true,
+            stream: true,
+            ...(watch ? { '--': ['--watch'] } : {}),
+        });
+    }
 
     describe(`${tsc.name}`, () => {
         const subject = async () => tsc(packages);
 
-        test('transpiles packages', async () => {
+        test('compiles and type checks packages', async () => {
             await subject();
 
-            expect(execa).toHaveBeenCalledWith(
-                'tsc',
-                ['-b', ...packages.map(({ location }) => getTsConfig(location))],
-                { stdio: 'inherit' }
-            );
-        });
-
-        describe('when package is dependency of another', () => {
-            beforeEach(() => {
-                jest.mocked(getPackagesGraph).mockReturnValue({
-                    [packages[0].name]: [packages[1].name], // packages[0] depends on packages[1]
-                });
-            });
-
-            test('transpiles only parent packages', async () => {
-                await subject();
-
-                expect(execa).toHaveBeenCalledWith(
-                    expect.anything(),
-                    ['-b', getTsConfig(packages[0].location)],
-                    expect.anything()
-                );
-            });
+            itRunsTscCompile();
         });
     });
 
     describe(`${tscWatch.name}`, () => {
         const subject = async () => tscWatch(packages);
 
-        test('transpiles packages in watch mode', async () => {
+        test('compiles and type checks packages in watch mode', async () => {
             await subject();
 
-            expect(execa).toHaveBeenCalledWith(
-                'tsc',
-                [
-                    '-b',
-                    '-w',
-                    '--preserveWatchOutput',
-                    ...packages.map(({ location }) => getTsConfig(location)),
-                ],
-                { stdio: 'inherit' }
-            );
+            itRunsTscCompilePackage(true);
+            itRunsTscCompile(true, true);
         });
     });
 });

package/src/cli/utils/bundle.ts

@@ -113,7 +113,7 @@ async function run(config: Configuration) {
             }
 
             if (stats.hasErrors()) {
-                return reject(stats.toString('errors-only'));
+                return reject(new Error(stats.toString('errors-only')));
             }
 
             compiler.close(() => resolve(stats));

package/src/cli/utils/cli-os.ts

@@ -25,7 +25,7 @@ export const runCommand = (
         const commandName = commandArray.shift();
 
         if (!commandName) {
-            reject();
+            reject(new Error('invalid command'));
 
             return;
         }
@@ -48,7 +48,7 @@ export const runCommand = (
             }
 
             if (code) {
-                reject();
+                reject(new Error(`command exited with code: ${code}`));
             } else {
                 resolve();
             }

package/src/cli/utils/eslint.ts

@@ -1,6 +1,6 @@
 import { ESLint } from 'eslint';
 
-import { getDestinationFolders, getESLintConfiguration } from '../../utils';
+import { getDestinationFolders, getESLintConfiguration, log } from '../../utils';
 
 interface Args {
     fix?: boolean;
@@ -14,21 +14,24 @@ export async function eslint({ fix, paths }: Args) {
         return;
     }
 
-    const eslint = new ESLint({
+    const options: ESLint.Options = {
         errorOnUnmatchedPattern: false,
-        extensions: ['.ts', '.tsx'],
-        baseConfig: {
-            ignorePatterns: [
-                'node_modules',
-                '*.css.d.ts',
-                '*.scss.d.ts',
-                '*.less.d.ts',
-                ...getDestinationFolders(),
-            ],
-        },
+        ignorePatterns: [
+            // **/node_modules/ is excluded by default
+            '.vscode/',
+            '**/.yalc/',
+            '**/*.css.d.ts',
+            '**/*.scss.d.ts',
+            '**/*.less.d.ts',
+            ...getDestinationFolders(),
+        ],
         fix,
         ...config,
-    });
+    };
+
+    log.debug('eslint-options', () => JSON.stringify(options, null, 2));
+
+    const eslint = new ESLint(options);
 
     let files = paths;
     if (files.length === 0) {

package/src/cli/utils/is-module-installed.ts

@@ -2,7 +2,7 @@ export function isModuleInstalled(name: string): boolean {
     try {
         require.resolve(name);
         return true;
-    } catch (e) {
+    } catch {
         return false;
     }
 }

package/src/cli/utils/tsc.ts

@@ -1,6 +1,7 @@
 import execa from 'execa';
 
-import { getPackagesGraph, getTsConfig, log, Package } from '../../utils';
+import { log, Package } from '../../utils';
+import { lernaExec } from './lerna-exec';
 
 export function tsc(packages: Package[]) {
     log.info('Building TypeScript files...');
@@ -8,26 +9,30 @@ export function tsc(packages: Package[]) {
 }
 
 export function tscWatch(packages: Package[]) {
-    return transpile(packages, ['-w', '--preserveWatchOutput']);
+    return transpile(packages, true);
 }
 
-async function transpile(packages: Package[], options: string[] = []) {
-    const args = [
-        '-b',
-        ...options,
-        ...collapsePackages(packages).map(({ location }) => getTsConfig(location)),
-    ];
-    log.debug('tsc', `Running tsc ${args.join(' ')}`);
-    await execa('tsc', args, { stdio: 'inherit' });
-}
-
-/**
- * Exclude dependant packages as they will be built through project references
- */
-function collapsePackages(packages: Package[]) {
-    const dependencies = new Set(
-        Object.values(getPackagesGraph({ scope: packages.map(({ name }) => name) })).flat()
-    );
+async function transpile(packages: Package[], watch = false) {
+    const packageNames = packages.map(({ name }) => name);
+    const packageScopes = packageNames.map(name => `--scope=${name}`);
+    if (watch) {
+        return Promise.all([
+            lernaExec({
+                'cmd': 'startup task tsc-compile-package',
+                'scope': packageNames,
+                'parallel': true,
+                'stream': true,
+                '--': ['--watch'],
+            }),
+            execa(
+                'startup',
+                ['task', 'tsc-compile', ...packageScopes, '--watch', '--type-check-only'],
+                { stdio: 'inherit' }
+            ),
+        ]);
+    }
 
-    return packages.filter(({ name }) => !dependencies.has(name));
+    return execa('startup', ['task', 'tsc-compile', ...packageScopes], {
+        stdio: 'inherit',
+    });
 }

package/src/utils/__tests__/get-destination-folders.test.ts

@@ -35,7 +35,7 @@ describe('[startup] Utils', () => {
         }
 
         function expectedOutDirs(locations: string[]) {
-            return locations.map(location => `/packages/${location}/${location}outDir/`);
+            return locations.map(location => `packages/${location}/${location}outDir/`);
         }
 
         test('returns outDir path for all packages', () => {

package/src/utils/__tests__/get-folders.test.ts

@@ -15,15 +15,9 @@ describe('[Startup] utils:get-folders', () => {
             'tsconfig.json': JSON.stringify({ compilerOptions: { ourDir: 'dist' } }),
         });
 
-        let error;
-
-        try {
-            getFolders();
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBe('"compilerOptions.rootDir" must be defined in the "tsconfig.json"!');
+        expect(() => getFolders()).toThrow(
+            '"compilerOptions.rootDir" must be defined in the "tsconfig.json"!'
+        );
     });
 
     test('getFolders throws an exception if "compilerOptions.outDir" isn\'t defined', () => {
@@ -32,15 +26,9 @@ describe('[Startup] utils:get-folders', () => {
             'tsconfig.json': JSON.stringify({ compilerOptions: { rootDir: 'src' } }),
         });
 
-        let error;
-
-        try {
-            getFolders();
-        } catch (e) {
-            error = e;
-        }
-
-        expect(error).toBe('"compilerOptions.outDir" must be defined in the "tsconfig.json"!');
+        expect(() => getFolders()).toThrow(
+            '"compilerOptions.outDir" must be defined in the "tsconfig.json"!'
+        );
     });
 
     test('"compilerOptions.outDir" used as the destination', () => {

package/src/utils/__tests__/log.test.ts

@@ -14,6 +14,12 @@ describe(`[startup] Utils`, () => {
             stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
         });
 
+        test('text() writes default text', () => {
+            log.text(message);
+
+            expect(stdoutSpy).toHaveBeenCalledWith(`${chalk(message)}\n`);
+        });
+
         test('info() writes cyan text', () => {
             log.info(message);