@servicetitan/startup 22.14.0 → 22.16.0

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

@@ -1,226 +1,135 @@
-jest.mock('../../../utils/get-folders');
-
+import chokidar from 'chokidar';
 import fs from 'fs';
-import mock from 'mock-fs';
-import { mocked } from 'ts-jest/utils';
+import mockFS from 'mock-fs';
 
-import { getFolders } from '../../../utils';
-import { tcm } from '..';
+import { getFolders, log } from '../../../utils';
+import * as sassModule from '../compile-sass';
 
-describe('[Startup] utils:tcm', () => {
-    beforeAll(() => {
-        mocked(getFolders).mockReturnValue({ source: 'src', destination: 'dist' });
-    });
+import { styleExtensions } from '..';
+import { tcm, tcmWatch } from '../tcm';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getFolders: jest.fn(),
+    log: { error: jest.fn(), info: jest.fn() }, // suppress test output
+}));
 
-    afterAll(() => {
-        mock.restore();
+describe('[startup] Cli Utils', () => {
+    const source = 'src';
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(getFolders).mockReturnValue({ source, destination: undefined });
     });
 
-    xtest('tcm ignores global selector for css modules', async () => {
-        mock({
-            src: {
-                'styles.module.css': `
-                    .a :global(.b) .c {
-                        display: none;
-                    }
-                `,
-            },
-        });
+    afterEach(() => mockFS.restore());
 
-        await tcm();
+    function mockStylesModule(module: string, id = 'foo') {
+        mockFS({ [source]: { [module]: `.${id} { display: none; }` } });
+    }
 
-        expect(fs.readFileSync('./src/styles.module.css.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.css.d.ts', 'utf8')).not.toContain(
-            'export const b: string;'
+    function expectTypeDefinitions(module: string, id = 'foo') {
+        expect(fs.readFileSync(`${source}/${module}.d.ts`, 'utf8')).toContain(
+            `export const ${id}: string;`
         );
-        expect(fs.readFileSync('./src/styles.module.css.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+    }
 
-    test('tcm ignores global selector for sass modules', async () => {
-        mock({
-            src: {
-                'styles.module.scss': `
-                    .a :global(.b) .c {
-                        display: none;
-                    }
-                `,
-            },
-        });
+    describe(`${tcm.name}`, () => {
+        const subject = async () => tcm();
 
-        await tcm();
+        describe.each(styleExtensions)('with %s module', extension => {
+            const module = `foo.module.${extension}`;
 
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).not.toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+            beforeEach(() => mockStylesModule(module));
+
+            test(`generates Typescript definitions for ${extension} module`, async () => {
+                await subject();
 
-    test('tcm ignores global selector for less modules', async () => {
-        mock({
-            src: {
-                'styles.module.less': `
-                    .a :global(.b) .c {
-                        display: none;
-                    }
-                `,
-            },
+                expectTypeDefinitions(module);
+            });
         });
 
-        await tcm();
+        describe('when an error occurs', () => {
+            beforeEach(() => {
+                mockStylesModule('foo.module.scss');
+                jest.spyOn(sassModule, 'compileSass').mockImplementation(() => {
+                    throw new Error('Oops!');
+                });
+            });
 
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).not.toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+            test('logs error', async () => {
+                await subject();
 
-    test('tcm handles nested selectors for sass modules', async () => {
-        mock({
-            src: {
-                'styles.module.scss': `
-                    .a :global(.b) {
-                        .c {
-                            display: none;
-                        }
-                    }
-                `,
-            },
+                expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Oops!'));
+            });
         });
+    });
 
-        await tcm();
+    describe(`${tcmWatch.name}`, () => {
+        type Listener = (path: string) => Promise<void>;
+        let watchSpy: jest.SpyInstance;
+        let fsWatcher: Partial<ReturnType<typeof chokidar.watch>>;
 
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).not.toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+        beforeAll(() => {
+            process.env.NODE_ENV ??= 'test'; // workaround issue with Jest not setting NODE_ENV=test
+        });
 
-    test('tcm handles nested selectors for less. modules', async () => {
-        mock({
-            src: {
-                'styles.module.less': `
-                    .a :global(.b) {
-                        .c {
-                            display: none;
-                        }
-                    }
-                `,
-            },
+        beforeEach(() => {
+            fsWatcher = { on: jest.fn() };
+            watchSpy = jest.spyOn(chokidar, 'watch').mockReturnValue(fsWatcher as any);
+            mockFS({ [source]: {} });
         });
 
-        await tcm();
+        const subject = () => tcmWatch();
 
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).not.toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+        test('watches for new and changed style modules', async () => {
+            await subject();
 
-    xtest('tcm handles imports for sass modules', async () => {
-        mock({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            node_modules: {
-                package: {
-                    'shared.scss': `
-                        .a {
-                            display: none;
-                        }
-                    `,
-                },
-            },
-            src: {
-                'styles.scss': `
-                    .b {
-                        display: none;
-                    }
-                `,
-                'styles.module.scss': `
-                    @import 'package/shared.scss';
-                    @import './styles.scss';
-
-                    .c {
-                        display: none;
-                    }
-                `,
-            },
+            expect(watchSpy).toHaveBeenCalledWith(
+                [`${source}/**/*.module.{${styleExtensions.join()}}`],
+                { ignoreInitial: true }
+            );
+            expect(fsWatcher.on).toHaveBeenCalledWith('add', expect.any(Function));
+            expect(fsWatcher.on).toHaveBeenCalledWith('change', expect.any(Function));
         });
 
-        await tcm();
+        function getListener(name: string) {
+            const { calls } = jest.mocked(fsWatcher.on)!.mock;
+            return calls.find(([event]) => event === name)![1] as Listener;
+        }
 
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.scss.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
-    });
+        describe('when module is added', () => {
+            const module = 'bar.module.scss';
+
+            const setup = async () => {
+                await subject();
+                mockStylesModule(module, 'bar');
+                await getListener('add')(`${source}/${module}`);
+            };
+
+            test('generates Typescript definitions for new module', async () => {
+                await setup();
 
-    xtest('tcm handles imports for less modules', async () => {
-        mock({
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            node_modules: {
-                package: {
-                    'shared.less': `
-                        .a {
-                            display: none;
-                        }
-                    `,
-                },
-            },
-            src: {
-                'styles.less': `
-                    .b {
-                        display: none;
-                    }
-                `,
-                'styles.module.less': `
-                    @import 'package/shared.less';
-                    @import './styles.less';
-
-                    .c {
-                        display: none;
-                    }
-                `,
-            },
+                expectTypeDefinitions(module, 'bar');
+            });
         });
 
-        await tcm();
+        describe('when module is changed', () => {
+            const module = 'baz.module.less';
 
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const a: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const b: string;'
-        );
-        expect(fs.readFileSync('./src/styles.module.less.d.ts', 'utf8')).toContain(
-            'export const c: string;'
-        );
+            const setup = async () => {
+                mockStylesModule(module, 'foo');
+                await subject();
+
+                mockStylesModule(module, 'baz');
+                await getListener('change')(`${source}/${module}`);
+            };
+
+            test('generates Typescript definitions for changed module', async () => {
+                await setup();
+
+                expectTypeDefinitions(module, 'baz');
+            });
+        });
     });
 });

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

@@ -0,0 +1,85 @@
+import execa from 'execa';
+import mockFS from 'mock-fs';
+import { Package, getPackagesGraph, getTsConfig } from '../../../utils';
+import { createPackage } from '../../__mocks__';
+
+import { tsc, tscWatch } from '../tsc';
+
+jest.mock('execa', () => jest.fn());
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { info: jest.fn() }, // suppress test output
+    getPackagesGraph: jest.fn(),
+}));
+
+describe('[startup] Cli Utils', () => {
+    let packages: Package[];
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(getPackagesGraph).mockReturnValue({});
+        packages = [
+            createPackage({ name: 'foo', location: 'packages/foo' }),
+            createPackage({ name: 'bar', location: 'packages/bar' }),
+        ];
+        mockFS({
+            packages: {
+                foo: { 'tsconfig.json': JSON.stringify({}) },
+                bar: { 'tsconfig.json': JSON.stringify({}) },
+            },
+        });
+    });
+
+    afterEach(() => mockFS.restore());
+
+    describe(`${tsc.name}`, () => {
+        const subject = async () => tsc(packages);
+
+        test('transpiles 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()
+                );
+            });
+        });
+    });
+
+    describe(`${tscWatch.name}`, () => {
+        const subject = async () => tscWatch(packages);
+
+        test('transpiles packages in watch mode', async () => {
+            await subject();
+
+            expect(execa).toHaveBeenCalledWith(
+                'tsc',
+                [
+                    '-b',
+                    '-w',
+                    '--preserveWatchOutput',
+                    ...packages.map(({ location }) => getTsConfig(location)),
+                ],
+                { stdio: 'inherit' }
+            );
+        });
+    });
+});

package/src/cli/utils/eslint.ts

@@ -0,0 +1,50 @@
+import { ESLint } from 'eslint';
+
+import { getDestinationFolders, getESLintConfiguration } from '../../utils';
+
+interface Args {
+    fix?: boolean;
+    paths: string[];
+}
+
+export async function eslint({ fix, paths }: Args) {
+    const { disabled, ...config } = getESLintConfiguration();
+
+    if (disabled) {
+        return;
+    }
+
+    const eslint = new ESLint({
+        errorOnUnmatchedPattern: false,
+        extensions: ['.ts', '.tsx'],
+        baseConfig: {
+            ignorePatterns: [
+                'node_modules',
+                '*.css.d.ts',
+                '*.scss.d.ts',
+                '*.less.d.ts',
+                ...getDestinationFolders(),
+            ],
+        },
+        fix,
+        ...config,
+    });
+
+    let files = paths;
+    if (files.length === 0) {
+        files = [process.cwd()];
+    }
+
+    const results = await eslint.lintFiles(files);
+
+    if (fix) {
+        await ESLint.outputFixes(results);
+    }
+
+    const formatter = await eslint.loadFormatter('stylish');
+    process.stdout.write(formatter.format(results) as string);
+
+    if (ESLint.getErrorResults(results).length) {
+        process.exitCode = 1;
+    }
+}

package/src/cli/utils/index.ts

@@ -5,8 +5,10 @@ export * from './assets-copy';
 export * from './bundle';
 export * from './compile-less';
 export * from './compile-sass';
+export * from './eslint';
 export * from './get-module-type';
 export * from './is-module-installed';
+export * from './set-node-options';
 export * from './styles-copy';
 export * from './tcm';
 export * from './tsc';

package/src/cli/utils/set-node-options.ts

@@ -0,0 +1,45 @@
+import os from 'os';
+import { NodeConfiguration, getConfiguration } from '../../utils';
+
+const MAX_OLD_SPACE_SIZE_OPTION = 'max_old_space_size';
+const DEFAULT_MAX_OLD_SPACE_SIZE_MB = 8192;
+const MIN_REMAINING_MEMORY_MB = 512;
+
+/**
+ * Apply global defaults and custom CLI configuration to process.env.NODE_OPTIONS
+ * @param command - the command being executed
+ * @returns whether process's NODE_OPTIONS were changed
+ */
+export function setNodeOptions(command: string) {
+    const cliConfig = getConfiguration();
+    const cmdConfig: NodeConfiguration = cliConfig[command];
+
+    const cmdNodeOptions = cmdConfig?.NODE_OPTIONS?.join(' ') ?? '';
+    const cliNodeOptions = cliConfig?.NODE_OPTIONS?.join(' ') ?? '';
+    const oldNodeOptions = process.env.NODE_OPTIONS ?? '';
+
+    const mergedOptions = [cmdNodeOptions, cliNodeOptions]
+        .reduce((result, options) => {
+            return result.includes(options) ? result : `${options} ${result}`;
+        }, oldNodeOptions)
+        .trim();
+
+    const newNodeOptions = ensureMaxOldSpaceSize(mergedOptions);
+    if (newNodeOptions !== oldNodeOptions) {
+        process.env.NODE_OPTIONS = newNodeOptions;
+        return true;
+    }
+
+    return false;
+}
+
+function ensureMaxOldSpaceSize(nodeOptions: string) {
+    return !nodeOptions.includes(MAX_OLD_SPACE_SIZE_OPTION)
+        ? `--${MAX_OLD_SPACE_SIZE_OPTION}=${getMaxOldSpaceSize()} ${nodeOptions}`.trim()
+        : nodeOptions;
+}
+
+function getMaxOldSpaceSize() {
+    const totalMB = os.totalmem() / (1024 * 1024);
+    return Math.min(DEFAULT_MAX_OLD_SPACE_SIZE_MB, Math.floor(totalMB - MIN_REMAINING_MEMORY_MB));
+}

package/src/cli/utils/tcm.ts

@@ -49,7 +49,9 @@ async function run({ watch }: RunOptions = {}) {
         watcher.on('add', writeFile);
         watcher.on('change', writeFile);
 
-        await new Promise<void>(() => {});
+        if (process.env.NODE_ENV !== 'test') {
+            await new Promise<void>(() => {});
+        }
     }
 }