@servicetitan/startup 28.5.0 → 30.0.0

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

@@ -1,10 +1,18 @@
 import { runCommand, runCommandOutput } from './cli-os';
 
+export interface Version {
+    name: string;
+    date: Date;
+    tag?: string;
+}
+
+const NPM_TIMEOUT = 10000;
+
 export function npmGetPackageVersions(registry: string, packageName: string): string[] {
     try {
         const v = runCommandOutput(
             `npm show ${packageName} versions --registry ${registry} --json`,
-            { timeout: 10000 }
+            { timeout: NPM_TIMEOUT }
         );
 
         return JSON.parse(v);
@@ -13,17 +21,22 @@ export function npmGetPackageVersions(registry: string, packageName: string): st
     }
 }
 
-export function npmGetPackageVersionDates(registry: string, packageName: string): [string, Date][] {
+export function npmGetPackageVersionsDetails(registry: string, packageName: string): Version[] {
     try {
-        const v = runCommandOutput(`npm view ${packageName} time --registry ${registry} --json`, {
-            timeout: 10000,
-        });
-        const map = JSON.parse(v);
+        const result = runCommandOutput(
+            `npm view ${packageName} time dist-tags --registry ${registry} --json`,
+            { timeout: NPM_TIMEOUT }
+        );
 
-        return Object.keys(map).reduce(
-            (out, version) => [...out, [version, new Date(map[version])]],
-            []
+        const { time, 'dist-tags': distTags } = JSON.parse(result);
+
+        const tags = Object.fromEntries(
+            Object.entries(distTags).map(([tag, version]) => [version, tag])
         );
+
+        return Object.keys(time).reduce((out, version) => {
+            return [...out, { name: version, date: new Date(time[version]), tag: tags[version] }];
+        }, []);
     } catch {
         return [];
     }
@@ -31,16 +44,12 @@ export function npmGetPackageVersionDates(registry: string, packageName: string)
 
 export async function npmUnpublish(registry: string, packageName: string, packageVersion: string) {
     await runCommand(`npm unpublish ${packageName}@${packageVersion} --registry ${registry}`, {
-        timeout: 10000,
+        timeout: NPM_TIMEOUT,
     });
 }
 
-export async function npmPublishDry() {
-    await runCommand('npm publish --dry-run');
-}
-
-export async function npmPublish(tag?: string) {
-    await runCommand(['npm publish', !!tag && `--tag ${tag}`]);
+export async function npmPublish({ dry, tag }: { dry?: boolean; tag?: string }) {
+    await runCommand(['npm publish', !!tag && `--tag ${tag}`, !!dry && `--dry-run`]);
 }
 
 export async function npmPackageSet(key: string, value: string) {

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

package/src/utils/get-configuration.ts

@@ -58,6 +58,7 @@ export interface NodeConfiguration {
 export enum CommandName {
     'build' = 'build',
     'bundle-package' = 'bundle-package',
+    'convert-eslint-config' = 'convert-eslint-config',
     'eslint' = 'eslint',
     'init' = 'init',
     'install' = 'install',
@@ -70,6 +71,7 @@ export enum CommandName {
     'start' = 'start',
     'styles-check' = 'styles-check',
     'test' = 'test',
+    'task' = 'task',
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 

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

@@ -8,24 +8,18 @@ import { getPackages, readJson } from '.';
  */
 export function getDestinationFolders() {
     const packages = getPackages();
+    const cwd = process.cwd();
 
-    return packages
-        .map(({ location }) => {
-            const tsConfigPath = path.join(location, 'tsconfig.json');
-
-            if (!fs.existsSync(tsConfigPath)) {
-                return '';
-            }
-
+    return packages.reduce<string[]>((result, { location }) => {
+        const tsConfigPath = path.join(location, 'tsconfig.json');
+        if (fs.existsSync(tsConfigPath)) {
             const { outDir } = readJson(tsConfigPath).compilerOptions ?? {};
-
-            if (!outDir) {
-                return '';
+            if (outDir) {
+                result.push(
+                    path.join(path.relative(cwd, location), outDir, '/').replace(/\\/g, '/')
+                );
             }
-
-            return path
-                .join('/', path.relative(process.cwd(), location), outDir, '/')
-                .replace(/\\/g, '/');
-        })
-        .filter(path => !!path);
+        }
+        return result;
+    }, []);
 }

package/src/utils/get-folders.ts

@@ -10,11 +10,11 @@ export function getFolders(location = './') {
         readJson(path.join(location, 'tsconfig.json')).compilerOptions ?? {};
 
     if (!rootDir) {
-        throw '"compilerOptions.rootDir" must be defined in the "tsconfig.json"!';
+        throw new Error('"compilerOptions.rootDir" must be defined in the "tsconfig.json"!');
     }
 
     if (!outDir) {
-        throw '"compilerOptions.outDir" must be defined in the "tsconfig.json"!';
+        throw new Error('"compilerOptions.outDir" must be defined in the "tsconfig.json"!');
     }
 
     return {

package/src/utils/log.ts

@@ -10,6 +10,10 @@ class Log {
         this.debugMap = new Map<string, Debugger>();
     }
 
+    text(...text: string[]) {
+        process.stdout.write(chalk(...text) + '\n');
+    }
+
     info(...text: string[]) {
         process.stdout.write(chalk.bold.cyan(...text) + '\n');
     }

package/src/webpack/configs/plugins/ignore-plugin/check-resource.ts

@@ -20,7 +20,7 @@ export function checkResource(packageContext: Context) {
         if (isOptionalReactDomPeerDependency({ resource, context })) {
             try {
                 require.resolve(resource);
-            } catch (e) {
+            } catch {
                 return true;
             }
         }