@servicetitan/startup 30.3.1 → 31.1.0

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

@@ -1,192 +0,0 @@
-import { swcDir } from '@swc/cli';
-import { log, readJson } from '../../../utils';
-import { SwcCompilePackage } from '../swc-compile-package';
-import { compilerOptions } from '../../../../tsconfig/base.json';
-
-jest.mock('@swc/cli', () => ({
-    swcDir: jest.fn(),
-}));
-
-jest.mock('../../../utils', () => ({
-    getFolders: jest.fn().mockReturnValue({
-        source: 'src',
-        destination: 'dist',
-    }),
-    log: { info: jest.fn(), text: jest.fn() },
-    readJsonSafe: jest.fn().mockReturnValue({}),
-    readJson: jest.fn().mockReturnValue({}),
-}));
-
-describe(`[startup] ${SwcCompilePackage.name} task`, () => {
-    beforeEach(() => {
-        globalThis.performance.clearMarks();
-        globalThis.performance.clearMeasures();
-        jest.clearAllMocks();
-        jest.restoreAllMocks();
-    });
-
-    let watch = false;
-
-    const subject = () => new SwcCompilePackage({ watch }).execute();
-
-    const onSuccessHandlerParams = {
-        duration: 10,
-    };
-    const callOnSuccessHandler = (parameters: { duration: number }) => {
-        jest.mocked(swcDir).mock.calls[0][0].callbacks.onSuccess(parameters);
-    };
-
-    const onFailHandlerParams = {
-        duration: 10,
-        reasons: new Map([['index.js', 'Syntax error']]),
-    };
-    const callOnFailHandler = (parameters: { duration: number; reasons: Map<string, string> }) => {
-        jest.mocked(swcDir).mock.calls[0][0].callbacks.onFail(parameters);
-    };
-
-    test('calls swcDir', () => {
-        subject();
-
-        expect(swcDir).toHaveBeenCalledWith({
-            cliOptions: {
-                watch: false,
-                outDir: 'dist',
-                stripLeadingPaths: true,
-                extensions: ['.ts', '.tsx'],
-                filenames: ['src'],
-            },
-            swcOptions: {
-                jsc: {
-                    parser: {
-                        syntax: 'typescript',
-                        tsx: true,
-                        decorators: true,
-                    },
-                    target: compilerOptions.target,
-                    transform: {
-                        legacyDecorator: compilerOptions.experimentalDecorators,
-                        decoratorMetadata: compilerOptions.emitDecoratorMetadata,
-                    },
-                },
-                sourceMaps: compilerOptions.sourceMap,
-                module: {
-                    type: 'es6',
-                },
-            },
-            callbacks: {
-                onSuccess: expect.any(Function),
-                onFail: expect.any(Function),
-            },
-        });
-    });
-
-    describe('when package is commonjs', () => {
-        beforeEach(() => {
-            jest.mocked(readJson).mockReturnValueOnce({
-                compilerOptions: { module: 'commonjs' },
-            });
-        });
-
-        test('swc module type is commonjs', () => {
-            subject();
-
-            expect(swcDir).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    swcOptions: expect.objectContaining({
-                        module: { type: 'commonjs' },
-                    }),
-                })
-            );
-        });
-    });
-
-    test('onSuccess handler completes task and logs completion message', async () => {
-        const task = subject();
-
-        callOnSuccessHandler(onSuccessHandlerParams);
-
-        await task;
-
-        expect(log.info).toHaveBeenCalledWith(
-            expect.stringMatching(
-                `swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
-            )
-        );
-    });
-
-    test('onFail handler fails task and logs completion message', async () => {
-        const task = subject();
-
-        callOnFailHandler(onFailHandlerParams);
-
-        await expect(task).rejects.toThrow('Compilation failed');
-
-        expect(log.text).toHaveBeenCalledWith('Syntax error');
-
-        expect(log.info).toHaveBeenCalledWith(
-            expect.stringMatching(
-                `swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
-            )
-        );
-    });
-
-    describe('in watch mode', () => {
-        beforeEach(() => (watch = true));
-
-        test('calls swcDir with watch=true', () => {
-            subject();
-
-            expect(swcDir).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    cliOptions: expect.objectContaining({
-                        watch: true,
-                    }),
-                })
-            );
-        });
-
-        test('onSuccess handler logs completion messages', () => {
-            subject();
-
-            callOnSuccessHandler(onSuccessHandlerParams);
-
-            expect(log.info).toHaveBeenCalledWith(
-                expect.stringMatching(
-                    `Initial swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
-                )
-            );
-
-            callOnSuccessHandler(onSuccessHandlerParams);
-
-            expect(log.info).toHaveBeenCalledWith(
-                expect.stringMatching(
-                    `Subsequent swc-compile-package task completed in ${onSuccessHandlerParams.duration}ms`
-                )
-            );
-        });
-
-        test('onFail handler logs completion message', () => {
-            subject();
-
-            callOnFailHandler(onFailHandlerParams);
-
-            expect(log.text).toHaveBeenCalledWith('Syntax error');
-
-            expect(log.info).toHaveBeenCalledWith(
-                expect.stringMatching(
-                    `Initial swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
-                )
-            );
-
-            callOnFailHandler(onFailHandlerParams);
-
-            expect(log.text).toHaveBeenCalledWith('Syntax error');
-
-            expect(log.info).toHaveBeenCalledWith(
-                expect.stringMatching(
-                    `Subsequent swc-compile-package task completed in ${onFailHandlerParams.duration}ms`
-                )
-            );
-        });
-    });
-});

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

@@ -1,52 +0,0 @@
-import cpx from 'cpx2';
-import { getFolders } from '../../../utils';
-
-import { assetsCopy, assetsCopyWatch } from '../assets-copy';
-import { assetExtensions } from '../index';
-
-jest.mock('cpx2', () => ({
-    copySync: jest.fn(),
-    watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
-}));
-jest.mock('../../../utils', () => ({
-    getFolders: jest.fn(),
-    log: { info: jest.fn() }, // suppress log output
-}));
-
-describe('[startup] Cli Utils (Assets)', () => {
-    const source = 'foo';
-    const destination = 'bar';
-
-    beforeEach(() => jest.mocked(getFolders).mockReturnValue({ source, destination }));
-
-    describe(`${assetsCopy.name}`, () => {
-        const subject = async () => assetsCopy();
-
-        test('copies assets from source to destination', async () => {
-            await subject();
-
-            expect(cpx.copySync).toHaveBeenCalledWith(
-                `${source}/**/*.{${assetExtensions.join()}}`,
-                destination
-            );
-        });
-    });
-
-    describe(`${assetsCopyWatch.name}`, () => {
-        const subject = async () => assetsCopyWatch();
-
-        test('copies assets from source to destination in watch mode', async () => {
-            try {
-                await subject();
-            } catch {
-                // ignore rejected promise that terminates watch()
-            }
-
-            expect(cpx.watch).toHaveBeenCalledWith(
-                `${source}/**/*.{${assetExtensions.join()}}`,
-                destination,
-                { initialCopy: false }
-            );
-        });
-    });
-});

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

@@ -1,52 +0,0 @@
-import cpx from 'cpx2';
-import { getFolders } from '../../../utils';
-
-import { stylesCopy, stylesCopyWatch } from '../styles-copy';
-import { styleExtensions } from '../index';
-
-jest.mock('cpx2', () => ({
-    copySync: jest.fn(),
-    watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
-}));
-jest.mock('../../../utils', () => ({
-    getFolders: jest.fn(),
-    log: { info: jest.fn() }, // suppress log output
-}));
-
-describe('[startup] Cli Utils (Styles)', () => {
-    const source = 'foo';
-    const destination = 'bar';
-
-    beforeEach(() => jest.mocked(getFolders).mockReturnValue({ source, destination }));
-
-    describe(`${stylesCopy.name}`, () => {
-        const subject = async () => stylesCopy();
-
-        test('copies styles from source to destination', async () => {
-            await subject();
-
-            expect(cpx.copySync).toHaveBeenCalledWith(
-                `${source}/**/*.{${styleExtensions.join()}}`,
-                destination
-            );
-        });
-    });
-
-    describe(`${stylesCopyWatch.name}`, () => {
-        const subject = () => stylesCopyWatch();
-
-        test('copies styles from source to destination in watch mode', async () => {
-            try {
-                await subject();
-            } catch {
-                // ignore rejected promise that terminates watch()
-            }
-
-            expect(cpx.watch).toHaveBeenCalledWith(
-                `${source}/**/*.{${styleExtensions.join()}}`,
-                destination,
-                { initialCopy: false }
-            );
-        });
-    });
-});

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

@@ -1,191 +0,0 @@
-/**
- * @jest-environment node
- */
-import chokidar from 'chokidar';
-import fs, { Stats } from 'fs';
-
-import { getFolders, log } from '../../../utils';
-import * as sassModule from '../compile-sass';
-
-import { styleExtensions } from '..';
-import { tcm, tcmWatch } from '../tcm';
-
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
-    getFolders: jest.fn(),
-    log: { debug: jest.fn(), error: jest.fn(), info: jest.fn() }, // suppress test output
-}));
-
-/**
- * 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).
- */
-
-describe('[startup] Cli Utils', () => {
-    const source = fs.mkdtempSync('src');
-
-    beforeEach(() => {
-        jest.resetAllMocks();
-        jest.mocked(getFolders).mockReturnValue({ source, destination: undefined });
-        fs.readdirSync(source).forEach(file => fs.rmSync(`${source}/${file}`));
-    });
-
-    afterAll(() => 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;`
-        );
-    }
-
-    describe(`${tcm.name}`, () => {
-        const subject = async () => tcm();
-
-        describe.each(styleExtensions)('with %s module', extension => {
-            const module = `foo.module.${extension}`;
-
-            beforeEach(() => mockStylesModule(module));
-
-            test(`generates Typescript definitions for ${extension} module`, async () => {
-                await subject();
-
-                expectTypeDefinitions(module);
-            });
-        });
-
-        describe('when an error occurs', () => {
-            beforeEach(() => {
-                mockStylesModule('foo.module.scss');
-                jest.spyOn(sassModule, 'compileSass').mockImplementation(() => {
-                    throw new Error('Oops!');
-                });
-            });
-
-            test('logs error', async () => {
-                await subject();
-
-                expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Oops!'));
-            });
-        });
-    });
-
-    describe(`${tcmWatch.name}`, () => {
-        type Listener = (path: string) => Promise<void>;
-        let watchSpy: jest.SpyInstance;
-        let fsWatcher: Partial<ReturnType<typeof chokidar.watch>>;
-
-        beforeEach(() => {
-            fsWatcher = { on: jest.fn() };
-            watchSpy = jest.spyOn(chokidar, 'watch').mockReturnValue(fsWatcher as any);
-            fs.writeFileSync(`${source}/foo.bar`, '');
-        });
-
-        const subject = () => tcmWatch();
-
-        test('watches for new and changed style modules', async () => {
-            await subject();
-
-            expect(watchSpy).toHaveBeenCalledWith(source, {
-                ignored: expect.any(Function),
-                ignoreInitial: true,
-            });
-            expect(fsWatcher.on).toHaveBeenCalledWith('add', expect.any(Function));
-            expect(fsWatcher.on).toHaveBeenCalledWith('change', expect.any(Function));
-        });
-
-        function getListener(name: string) {
-            const { calls } = jest.mocked(fsWatcher.on)!.mock;
-            return calls.find(([event]) => event === name)![1] as Listener;
-        }
-
-        describe('"ignored" filter', () => {
-            const styleExtensions = ['.module.css', '.module.scss', '.module.less'];
-            let ignored: (path: string, stats?: Partial<Stats>) => boolean;
-            let filePath: string;
-            let stats: Partial<Stats> | undefined;
-
-            beforeEach(async () => {
-                await tcmWatch();
-                const { calls } = watchSpy.mock;
-                ignored = calls[0][1].ignored;
-                stats = { isFile: () => true };
-            });
-
-            const subject = () => ignored(filePath, stats);
-
-            function itReturns(value: boolean) {
-                test(`returns ${value}`, () => expect(subject()).toBe(value));
-            }
-
-            describe.each(styleExtensions)('when path ends with %s', ext => {
-                beforeEach(() => (filePath = `foo${ext}`));
-
-                itReturns(false);
-            });
-
-            describe.each(styleExtensions)('when path contains %s', ext => {
-                beforeEach(() => (filePath = `foo${ext}.d.ts`));
-
-                itReturns(true);
-            });
-
-            describe.each(['', '.scss', '.tsx'])('when path ends with "%s"', ext => {
-                beforeEach(() => (filePath = `foo${ext}`));
-
-                itReturns(true);
-
-                describe('when stats is undefined', () => {
-                    beforeEach(() => (stats = undefined));
-
-                    itReturns(false);
-                });
-
-                describe('when stats.isFile returns false', () => {
-                    beforeEach(() => (stats = { isFile: () => false }));
-
-                    itReturns(false);
-                });
-            });
-        });
-
-        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();
-
-                expectTypeDefinitions(module, 'bar');
-            });
-        });
-
-        describe('when module is changed', () => {
-            const module = 'baz.module.less';
-
-            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

@@ -1,63 +0,0 @@
-import execa from 'execa';
-import { lernaExec } from '../lerna-exec';
-
-import { tsc, tscWatch } from '../tsc';
-import { createPackage } from '../../../__mocks__';
-
-jest.mock('execa', () => jest.fn());
-jest.mock('../lerna-exec', () => ({
-    lernaExec: jest.fn(),
-}));
-
-describe('[startup] Cli Utils', () => {
-    const packages = ['foo', 'bar'].map(name => createPackage({ name }));
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    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('compiles and type checks packages', async () => {
-            await subject();
-
-            itRunsTscCompile();
-        });
-    });
-
-    describe(`${tscWatch.name}`, () => {
-        const subject = async () => tscWatch(packages);
-
-        test('compiles and type checks packages in watch mode', async () => {
-            await subject();
-
-            itRunsTscCompilePackage(true);
-            itRunsTscCompile(true, true);
-        });
-    });
-});

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

@@ -1,23 +0,0 @@
-import cpx from 'cpx2';
-
-import { getFolders, log } from '../../utils';
-import { assetExtensions } from '.';
-
-export function assetsCopy() {
-    const { source, destination } = getFolders();
-
-    log.info('Copying asset files...');
-
-    cpx.copySync(`${source}/**/*.{${assetExtensions.join()}}`, destination);
-    return Promise.resolve();
-}
-
-export async function assetsCopyWatch() {
-    const { source, destination } = getFolders();
-
-    await new Promise<void>((_0, reject) => {
-        cpx.watch(`${source}/**/*.{${assetExtensions.join()}}`, destination, {
-            initialCopy: false,
-        }).on('watch-error', reject);
-    });
-}

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

@@ -1,23 +0,0 @@
-import cpx from 'cpx2';
-
-import { getFolders, log } from '../../utils';
-import { styleExtensions } from '.';
-
-export function stylesCopy() {
-    const { source, destination } = getFolders();
-
-    log.info('Copying style files...');
-
-    cpx.copySync(`${source}/**/*.{${styleExtensions.join()}}`, destination);
-    return Promise.resolve();
-}
-
-export async function stylesCopyWatch() {
-    const { source, destination } = getFolders();
-
-    await new Promise<void>((_0, reject) => {
-        cpx.watch(`${source}/**/*.{${styleExtensions.join()}}`, destination, {
-            initialCopy: false,
-        }).on('watch-error', reject);
-    });
-}

package/src/cli/utils/tcm.ts

@@ -1,76 +0,0 @@
-import { glob } from 'glob';
-import chokidar from 'chokidar';
-
-import DtsCreator from 'typed-css-modules';
-
-import { getFolders, log } from '../../utils';
-import { compileLess, compileSass, styleExtensions } from '.';
-
-interface RunOptions {
-    watch?: boolean;
-}
-
-async function compile(filePath: string) {
-    if (filePath.endsWith('.less')) {
-        return compileLess(filePath);
-    }
-    if (filePath.endsWith('.scss')) {
-        return compileSass(filePath);
-    }
-}
-
-async function run({ watch }: RunOptions = {}) {
-    const source = getFolders().source.replace(/\\/g, '/');
-    const filesPattern = `${source}/**/*.module.{${styleExtensions.join()}}`;
-
-    const creator = new DtsCreator({
-        camelCase: true,
-        namedExports: true,
-    });
-
-    const writeFile = async (filePath: string) => {
-        try {
-            const initialContents = await compile(filePath);
-            const content = await creator.create(filePath, initialContents, !!watch);
-            await content.writeFile();
-        } catch (error) {
-            log.error(String(error));
-        }
-    };
-
-    if (!watch) {
-        const files = await glob(filesPattern);
-        await Promise.all(files.map(writeFile));
-        return;
-    }
-
-    log.info('Watch ' + filesPattern + '...');
-
-    const stylesRegex = new RegExp(`\\.module\\.(${styleExtensions.join('|')})$`);
-    const watcher = chokidar.watch(source, {
-        ignored: (path, stats) => !!stats?.isFile() && !stylesRegex.test(path),
-        ignoreInitial: true,
-    });
-    const callback = async (path: string) => {
-        log.debug('tcm', `Compiling ${path}`);
-        await writeFile(path);
-    };
-
-    watcher.on('add', callback);
-    watcher.on('change', callback);
-
-    /* istanbul ignore next: not executed in test environment */
-    if (process.env.NODE_ENV !== 'test') {
-        await new Promise<void>(() => {});
-    }
-}
-
-export async function tcm() {
-    log.info('Generating TypeScript definition files for Style Modules...');
-
-    await run();
-}
-
-export async function tcmWatch() {
-    await run({ watch: true });
-}