@servicetitan/startup 28.5.0 → 30.0.0

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

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-npm.test.ts

@@ -1,11 +1,10 @@
 import { runCommand, runCommandOutput } from '../cli-os';
 
 import {
-    npmGetPackageVersionDates,
     npmGetPackageVersions,
+    npmGetPackageVersionsDetails,
     npmPackageSet,
     npmPublish,
-    npmPublishDry,
     npmTagVersion,
     npmUnpublish,
 } from '../cli-npm';
@@ -48,7 +47,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     }
 
-    describe(`${npmGetPackageVersions.name}`, () => {
+    describe(npmGetPackageVersions.name, () => {
         let args: Parameters<typeof npmGetPackageVersions>;
 
         beforeEach(() => (args = ['{registry}', '{packageName}']));
@@ -82,30 +81,42 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
-    describe(`${npmGetPackageVersionDates.name}`, () => {
-        let args: Parameters<typeof npmGetPackageVersionDates>;
+    describe(npmGetPackageVersionsDetails.name, () => {
+        let args: Parameters<typeof npmGetPackageVersionsDetails>;
 
-        beforeEach(() => (args = ['{registry}', '{packageName}']));
+        beforeEach(() => {
+            jest.useFakeTimers();
+            args = ['{registry}', '{packageName}'];
+        });
 
-        const subject = () => npmGetPackageVersionDates(...args);
+        afterEach(() => jest.useRealTimers());
 
-        itRunsCommandOutput(subject, 'npm view {packageName} time --registry {registry} --json', {
-            timeout: 10000,
-        });
+        const subject = () => npmGetPackageVersionsDetails(...args);
+
+        itRunsCommandOutput(
+            subject,
+            'npm view {packageName} time dist-tags --registry {registry} --json',
+            { timeout: 10000 }
+        );
 
-        test('converts results to Array<[string, Date]>', () => {
+        test('converts results to Version[]', () => {
             function dayAgo(count: number) {
                 const date = new Date();
                 date.setDate(-count);
                 return date;
             }
-            const result = { '1.0.1': dayAgo(3), '2.1.0': dayAgo(2), '3.0.0': dayAgo(1) };
+            const result = {
+                'time': { '1.0.1': dayAgo(3), '2.1.0': dayAgo(2), '3.0.0': dayAgo(1) },
+                'dist-tags': { latest: '3.0.0' },
+            };
 
             jest.mocked(runCommandOutput).mockReturnValue(JSON.stringify(result));
 
-            expect(subject()).toEqual(
-                Object.entries(result).map(([version, date]) => [version, date])
-            );
+            expect(subject()).toEqual([
+                { name: '1.0.1', date: dayAgo(3) },
+                { name: '2.1.0', date: dayAgo(2) },
+                { name: '3.0.0', date: dayAgo(1), tag: 'latest' },
+            ]);
         });
 
         describe('when an error occurs', () => {
@@ -121,7 +132,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
-    describe(`${npmPackageSet.name}`, () => {
+    describe(npmPackageSet.name, () => {
         let args: Parameters<typeof npmPackageSet>;
 
         beforeEach(() => (args = ['{key}', '{value}']));
@@ -131,27 +142,29 @@ describe('[startup] Cli Utils (Npm)', () => {
         itRunsCommand(subject, 'npm pkg set {key}={value}');
     });
 
-    describe(`${npmPublish.name}`, () => {
-        let args: Parameters<typeof npmPublish>;
+    describe(npmPublish.name, () => {
+        let options: Parameters<typeof npmPublish>[0];
 
-        beforeEach(() => (args = []));
+        beforeEach(() => (options = {}));
 
-        const subject = async () => npmPublish(...args);
+        const subject = async () => npmPublish(options);
 
         itRunsCommand(subject, 'npm publish');
 
         describe('with a tag', () => {
-            beforeEach(() => args.push('{tag}'));
+            beforeEach(() => (options.tag = '{tag}'));
 
             itRunsCommand(subject, 'npm publish --tag {tag}');
         });
-    });
 
-    describe(`${npmPublishDry.name}`, () => {
-        itRunsCommand(npmPublishDry, 'npm publish --dry-run');
+        describe('with {dry: true}', () => {
+            beforeEach(() => (options.dry = true));
+
+            itRunsCommand(subject, 'npm publish --dry-run');
+        });
     });
 
-    describe(`${npmUnpublish.name}`, () => {
+    describe(npmUnpublish.name, () => {
         let args: Parameters<typeof npmUnpublish>;
 
         beforeEach(() => (args = ['{registry}', '{packageName}', '{packageVersion}']));
@@ -165,7 +178,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         );
     });
 
-    describe(`${npmTagVersion.name}`, () => {
+    describe(npmTagVersion.name, () => {
         let args: Parameters<typeof npmTagVersion>[0];
 
         beforeEach(() => {

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