@servicetitan/startup 30.3.0 → 31.0.0

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

@@ -1,70 +1,96 @@
 import { swcDir } from '@swc/cli';
-import { compilerOptions as baseCompilerOptions } from '../../../tsconfig/base.json';
+import deepmerge from 'deepmerge';
 
+import { compilerOptions as baseCompilerOptions } from '../../../tsconfig/base.json';
 import { Task } from './task';
-import { getFolders, log, readJson } from '../../utils';
+import { getFolders, getSwcCompilePackageConfiguration, log, readJson } from '../../utils';
 
 interface Args {
     [key: string]: unknown;
     watch?: boolean;
 }
 
+function toLowerCase(input: string | undefined): string | undefined {
+    return input?.toLowerCase();
+}
+
+function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
+    return sourceArray;
+}
+
 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 ?? {};
+        const packageConfig = getSwcCompilePackageConfiguration();
 
         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,
+            swcDir(
+                deepmerge(
+                    {
+                        cliOptions: {
+                            watch: this.watch,
+                            outDir: destination,
+                            stripLeadingPaths: true,
+                            extensions: ['.ts', '.tsx'],
+                            filenames: [source],
+                            ignore: [
+                                '**/*.d.ts',
+                                '**/__tests__/*',
+                                '**/*.test.*',
+                                '**/__mocks__/*',
+                            ],
+                            copyFiles: true,
                         },
-                        target: baseCompilerOptions.target,
-                        transform: {
-                            legacyDecorator: baseCompilerOptions.experimentalDecorators,
-                            decoratorMetadata: baseCompilerOptions.emitDecoratorMetadata,
+                        swcOptions: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                    decorators: true,
+                                },
+                                target: baseCompilerOptions.target,
+                                transform: {
+                                    legacyDecorator: baseCompilerOptions.experimentalDecorators,
+                                    decoratorMetadata: baseCompilerOptions.emitDecoratorMetadata,
+                                    react: {
+                                        runtime: 'automatic',
+                                    },
+                                },
+                            },
+                            sourceMaps: baseCompilerOptions.sourceMap,
+                            module: {
+                                type:
+                                    toLowerCase(compilerOptions.module) === 'commonjs' ||
+                                    toLowerCase(compilerOptions.module) === 'nodenext'
+                                        ? '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'));
+                                }
+                            },
                         },
                     },
-                    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'));
-                        }
-                    },
-                },
-            });
+                    packageConfig,
+                    { arrayMerge: overwriteMerge, clone: false }
+                )
+            );
         });
     }
 }

package/src/cli/tasks/task.ts

@@ -1,4 +1,4 @@
-import { log, readJsonSafe } from '../../utils';
+import { formatDuration, log, readJsonSafe } from '../../utils';
 
 class TaskTimer {
     private counter = 0;
@@ -85,17 +85,10 @@ export abstract class Task {
     }) {
         const enumerator = counter === 0 ? 'Initial ' : 'Subsequent ';
         log.info(
-            `${this.watch ? enumerator : ''}${this.name} task completed in ${this.formatDuration(measure.duration)}`
+            `${this.watch ? enumerator : ''}${this.name} task completed in ${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) {
@@ -106,7 +99,5 @@ export abstract class Task {
         }
     }
 
-    abstract description(): string;
-
     abstract execute(): Promise<void>;
 }

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

@@ -18,10 +18,6 @@ export class TscCompilePackage extends CliTask {
         });
     }
 
-    description() {
-        return 'Compiles TypeScript files to JavaScript with TSC within package folder';
-    }
-
     async execute() {
         const tsConfig = getTsConfig();
         await this.runChildProcess(

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

@@ -1,11 +1,4 @@
-import {
-    getPackages,
-    getPackagesGraph,
-    getTsConfig,
-    Package,
-    PackageType,
-    splitPackagesByType,
-} from '../../utils';
+import { getPackages, getPackagesGraph, getTsConfig, log, Package, PackageType } from '../../utils';
 import { CliTask } from './cli-task';
 
 interface Args {
@@ -13,7 +6,6 @@ interface Args {
     ignore?: string | string[];
     scope?: string | string[];
     watch?: boolean;
-    typeCheckOnly?: boolean;
 }
 
 export class TscCompile extends CliTask {
@@ -29,15 +21,20 @@ export class TscCompile extends CliTask {
         });
     }
 
-    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 packages = getPackages({
+            scope: this.args.scope,
+            ignore: this.args.ignore,
+            type: [PackageType.TSC, PackageType.Webpack],
+        });
+
         const tsConfigs = collapsePackages(packages).map(({ location }) => getTsConfig(location));
+
+        log.debug(
+            'tsc-compile',
+            `${this.args.watch ? 'watching' : 'compiling'} ${tsConfigs.join(' ')}`
+        );
+
         await this.runChildProcess(
             'tsc',
             [
@@ -45,7 +42,7 @@ export class TscCompile extends CliTask {
                 this.watch ? '-w' : undefined,
                 '--pretty',
                 '--preserveWatchOutput',
-                this.args.typeCheckOnly ? '--emitDeclarationOnly' : undefined,
+                '--emitDeclarationOnly',
                 ...tsConfigs,
             ].filter(i => i !== undefined)
         );

package/src/cli/types/cpx2.d.ts

@@ -1,3 +1,10 @@
 declare module 'cpx2' {
-    export * from '@types/cpx';
+    import { WatchOptions } from '@types/cpx';
+
+    interface Cpx2WatchOptions extends WatchOptions {
+        ignore?: string | string[];
+    }
+
+    export { copy, copySync } from '@types/cpx';
+    export function watch(source: string, dest: string, options?: Cpx2WatchOptions): Watcher;
 }

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

@@ -73,7 +73,7 @@ describe('[startup] Cli Utils', () => {
 
         beforeEach(() => {
             vol.fromJSON(packageFS());
-            options = { buildStat: false };
+            options = undefined;
             stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
             compiler.run = jest.fn(callback => callback(null, stats as any));
             // Allows config file to be loaded with require(...)

package/src/cli/utils/__tests__/check-args.test.ts

@@ -0,0 +1,34 @@
+import { checkArgs } from '../check-args';
+import { log } from '../../../utils';
+
+jest.mock('../../../utils', () => ({ log: { warning: jest.fn() } }));
+
+describe(checkArgs.name, () => {
+    let args: Parameters<typeof checkArgs>[0];
+    let options: Parameters<typeof checkArgs>[1];
+
+    beforeEach(() => {
+        args = { foo: true };
+        options = {};
+    });
+
+    const subject = () => checkArgs(args, options);
+
+    test('logs nothing', () => {
+        subject();
+
+        expect(log.warning).not.toHaveBeenCalled();
+    });
+
+    describe('when argument is obsolete', () => {
+        beforeEach(() => (options = { obsolete: ['foo'] }));
+
+        test('logs warning', () => {
+            subject();
+
+            expect(log.warning).toHaveBeenCalledWith(
+                expect.stringMatching(/WARNING: \w+ option is obsolete and is ignored/)
+            );
+        });
+    });
+});

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

@@ -0,0 +1,59 @@
+import { lernaExec } from '../lerna-exec';
+import { compile } from '../compile';
+
+jest.mock('../lerna-exec', () => ({
+    lernaExec: jest.fn(),
+}));
+
+describe('[startup] Cli Utils', () => {
+    const packages = ['foo', 'bar'];
+    let args: Parameters<typeof compile>[0];
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = { packages };
+    });
+
+    function itRunsSwcCompilePackage({ watch }: { watch?: boolean } = {}) {
+        expect(lernaExec).toHaveBeenCalledWith({
+            cmd: 'startup task swc-compile-package',
+            parallel: true,
+            scope: packages,
+            stream: true,
+            stdio: watch ? ['inherit', 'pipe', 'inherit'] : 'inherit',
+            ...(watch ? { '--': ['--watch'] } : {}),
+        });
+    }
+
+    describe(`${compile.name}`, () => {
+        const subject = async () => compile(args);
+
+        test('compiles packages', async () => {
+            await subject();
+
+            itRunsSwcCompilePackage();
+        });
+
+        describe('with "watch"', () => {
+            beforeEach(() => (args.watch = true));
+
+            test('compiles packages in watch mode', async () => {
+                await subject();
+
+                itRunsSwcCompilePackage({ watch: true });
+            });
+        });
+
+        describe('with "useTsc"', () => {
+            beforeEach(() => (args.useTsc = true));
+
+            test('runs tsc-compile-package', async () => {
+                await subject();
+
+                expect(lernaExec).toHaveBeenCalledWith(
+                    expect.objectContaining({ cmd: 'startup task tsc-compile-package' })
+                );
+            });
+        });
+    });
+});

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

@@ -0,0 +1,157 @@
+/**
+ * @jest-environment node
+ */
+import cpx from 'cpx2';
+import fs from 'fs';
+import { getFolders, log } from '../../../utils';
+import * as compileSassModule from '../compile-sass';
+
+import { assetExtensions, copyFiles, styleExtensions } from '../copy-files';
+
+jest.mock('cpx2', () => ({
+    copy: jest.fn(),
+    watch: jest.fn(),
+}));
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getFolders: jest.fn(),
+    log: { debug: jest.fn(), info: jest.fn(), error: jest.fn() },
+}));
+
+/**
+ * Note: These tests don't use memfs because the typed-css-modules package
+ * uses node: URLs to import the fs modules, which bypasses the memfs filesystem
+ * (as of memfs ~4.6.0). Also sass requires the jest-environment be set to "node".
+ */
+
+describe(`[startup] cli utils (${copyFiles.name})`, () => {
+    const source = fs.mkdtempSync('src');
+    const destination = 'dist';
+    const files = `${source}/**/*.{${[...assetExtensions, ...styleExtensions].join(',')}}`;
+    let options: Parameters<typeof copyFiles>[0];
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(getFolders).mockReturnValue({ source, destination });
+        fs.readdirSync(source).forEach(file => fs.rmSync(`${source}/${file}`));
+
+        options = {};
+
+        jest.mocked(cpx.watch).mockImplementation(() => {
+            const emitter: { on?: Function } = {};
+            emitter.on = jest.fn((_event: string, _handler: Function) => emitter);
+            return emitter;
+        });
+    });
+
+    afterAll(() => {
+        if (fs.existsSync(source)) {
+            fs.rmSync(source, { recursive: true });
+        }
+    });
+
+    function mockStylesModule(module: string, id = 'foo') {
+        const content = `.${id} { display: none; }`;
+        fs.writeFileSync(`${source}/${module}`, content);
+    }
+
+    function expectTypeDefinitions(module: string, id = 'foo') {
+        expect(fs.readFileSync(`${source}/${module}.d.ts`, 'utf8')).toContain(
+            `export const ${id}: string;`
+        );
+    }
+
+    function getHandler(event: string) {
+        const emitter = jest.mocked(cpx.watch).mock.results[0].value;
+        const { calls } = jest.mocked(emitter.on).mock;
+        return calls.find(([name]: string[]) => name === event)[1] as Function;
+    }
+
+    const subject = async () => copyFiles(options);
+
+    test('copies assets and styles from source to destination', async () => {
+        await subject();
+
+        expect(cpx.copy).toHaveBeenCalledWith(files, destination);
+    });
+
+    describe.each(styleExtensions)('with %s module', extension => {
+        const module = `foo.module.${extension}`;
+
+        beforeEach(() => mockStylesModule(module));
+
+        test(`generates types for ${extension} module`, async () => {
+            await subject();
+
+            expectTypeDefinitions(module);
+        });
+    });
+
+    describe('when an error occurs generating types', () => {
+        const errorMessage = 'Oops!';
+
+        beforeEach(() => {
+            mockStylesModule('foo.module.scss');
+            jest.spyOn(compileSassModule, 'compileSass').mockImplementation(() => {
+                throw new Error(errorMessage);
+            });
+        });
+
+        test('logs error', async () => {
+            await subject();
+
+            expect(log.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage));
+        });
+    });
+
+    describe('with {watch: true}', () => {
+        beforeEach(() => (options = { watch: true }));
+
+        test('watches files', async () => {
+            await subject();
+
+            expect(cpx.watch).toHaveBeenCalledWith(
+                files,
+                destination,
+                expect.objectContaining({ initialCopy: false })
+            );
+        });
+
+        describe('when module is changed', () => {
+            const module = 'foo.module.scss';
+
+            beforeEach(async () => {
+                mockStylesModule(module);
+                await subject();
+                await getHandler('copy')({ srcPath: `${source}/${module}` });
+            });
+
+            test('generates types', () => {
+                expectTypeDefinitions(module);
+            });
+        });
+
+        describe('when an error occurs watching files', () => {
+            const errorMessage = 'Nope!';
+
+            beforeEach(async () => {
+                await subject();
+                await getHandler('watch-error')(new Error(errorMessage));
+            });
+
+            test('logs error', () => {
+                expect(log.error).toHaveBeenCalledWith(expect.stringContaining(errorMessage));
+            });
+        });
+    });
+
+    describe('when source location does not exist', () => {
+        beforeEach(() => fs.rmSync(source, { recursive: true }));
+
+        test('does not copy files', async () => {
+            await subject();
+
+            expect(cpx.copy).not.toHaveBeenCalledWith();
+        });
+    });
+});

package/src/cli/utils/__tests__/get-module-type.test.ts

@@ -47,5 +47,24 @@ describe('[startup] Cli Utils', () => {
                 expect(subject()).toBe(module);
             });
         });
+
+        describe('when config extends relative path', () => {
+            const module = 'baz';
+
+            beforeEach(() => {
+                vol.fromJSON({
+                    'base.json': JSON.stringify({
+                        compilerOptions: { module },
+                    }),
+                    'foo/tsconfig.json': JSON.stringify({
+                        extends: '../base.json',
+                    }),
+                });
+            });
+
+            test("returns extended config's module", () => {
+                expect(subject('foo/tsconfig.json')).toBe(module);
+            });
+        });
     });
 });

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -5,6 +5,13 @@ import { lernaExec } from '../lerna-exec';
 
 jest.mock('execa');
 
+const AVAILABLE_PARALLELISM = 2;
+
+jest.mock('node:os', () => ({
+    ...jest.requireActual('node:os'),
+    availableParallelism: () => AVAILABLE_PARALLELISM,
+}));
+
 describe(`${lernaExec.name}`, () => {
     let args: Parameters<typeof lernaExec>[0];
 
@@ -12,34 +19,60 @@ describe(`${lernaExec.name}`, () => {
         jest.clearAllMocks();
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
         args = { cmd: 'foo' };
+        delete process.env.CI;
     });
 
     const subject = () => lernaExec(args);
 
     function expectExecaCalledWith(commandLine: string) {
         const [cmd, ...args] = commandLine.split(' ');
-        expect(execa).toHaveBeenCalledWith(cmd, args, { stdio: 'inherit' });
+        expect(execa).toHaveBeenCalledWith(cmd, args, {
+            stdio: 'inherit',
+            env: {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                FORCE_COLOR: 'true',
+            },
+        });
     }
 
-    test('runs "lerna exec -- {cmd}" command', () => {
-        subject();
+    function itRunsLernaExec(option?: string) {
+        const optionString = option ? ` ${option}` : '';
+        test(`runs "lerna exec${optionString} -- {cmd}"`, () => {
+            subject();
 
-        expectExecaCalledWith(`lerna exec -- ${args.cmd}`);
-    });
+            expectExecaCalledWith(`lerna exec${optionString} -- ${args.cmd}`);
+        });
+    }
+
+    itRunsLernaExec();
 
     describe.each([
         { arg: { parallel: true }, option: '--parallel' },
         { arg: { stream: true }, option: '--stream' },
         { arg: { bail: false }, option: '--no-bail' },
-        { arg: { concurrency: 1 }, option: '--concurrency=1' },
-        { arg: { concurrency: 0 }, option: '--concurrency=0' },
+        { arg: { parallel: 1 }, option: '--concurrency=1' },
+        { arg: { parallel: 0 }, option: '--concurrency=0' },
     ] as { arg: Partial<typeof args>; option: string }[])('with $arg', ({ arg, option }) => {
-        beforeEach(() => Object.assign(args, arg));
+        beforeEach(() => {
+            Object.assign(args, arg);
+        });
 
-        test(`runs "lerna exec ${option} -- {cmd}"`, () => {
-            subject();
+        itRunsLernaExec(option);
+    });
 
-            expectExecaCalledWith(`lerna exec ${option} -- ${args.cmd}`);
+    describe('when process.env.CI=true', () => {
+        beforeEach(() => {
+            process.env.CI = 'true';
+        });
+        describe.each([
+            { arg: { parallel: true }, option: `--concurrency=${AVAILABLE_PARALLELISM}` },
+            { arg: { parallel: 10 }, option: '--concurrency=10' },
+        ] as { arg: Partial<typeof args>; option: string }[])('with $arg', ({ arg, option }) => {
+            beforeEach(() => {
+                Object.assign(args, arg);
+            });
+
+            itRunsLernaExec(option);
         });
     });
 
@@ -63,4 +96,18 @@ describe(`${lernaExec.name}`, () => {
             expectExecaCalledWith(`lerna exec -- ${args.cmd} ${args['--']!.join(' ')}`);
         });
     });
+
+    describe('with "stdio"', () => {
+        beforeEach(() => (args.stdio = 'ignore'));
+
+        test('runs execa with stdio option', () => {
+            subject();
+
+            expect(execa).toHaveBeenCalledWith(
+                'lerna',
+                expect.any(Array),
+                expect.objectContaining({ stdio: args.stdio })
+            );
+        });
+    });
 });