@servicetitan/startup 27.4.0 → 28.0.0

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

@@ -5,10 +5,7 @@ import { assetsCopy, assetsCopyWatch } from '../assets-copy';
 import { assetExtensions } from '../index';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
+    copySync: jest.fn(),
     watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
 }));
 jest.mock('../../../utils', () => ({
@@ -28,10 +25,9 @@ describe('[startup] Cli Utils (Assets)', () => {
         test('copies assets from source to destination', async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
+            expect(cpx.copySync).toHaveBeenCalledWith(
                 `${source}/**/*.{${assetExtensions.join()}}`,
-                destination,
-                expect.anything()
+                destination
             );
         });
     });

package/src/cli/utils/__tests__/cli-os.test.ts

@@ -1,6 +1,7 @@
 import { execSync, spawn } from 'child_process';
 
 import { runCommand, runCommandOutput } from '../cli-os';
+import { log } from '../../../utils';
 
 jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
 jest.mock('../../../utils', () => ({ log: { info: jest.fn() } })); // suppress log output
@@ -11,6 +12,7 @@ describe('[startup] Cli Utils (OS)', () => {
         let childProcess: ReturnType<typeof spawn>;
 
         beforeEach(() => {
+            jest.clearAllMocks();
             exitCode = 0;
             childProcess = {
                 stderr: { pipe: jest.fn() },
@@ -25,7 +27,7 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command', () => {
             expect(subject('foo bar')).resolves.toBe(undefined);
 
-            expect(spawn).toHaveBeenCalledWith('foo', ['bar'], undefined);
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar'], {});
         });
 
         test('runs command with options', async () => {
@@ -37,7 +39,7 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command array', async () => {
             await subject(['foo', 'bar', '--baz']);
 
-            expect(spawn).toHaveBeenCalledWith('foo', ['bar', '--baz'], undefined);
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar', '--baz'], {});
         });
 
         test("pipes stdout and stderr to parent's streams", async () => {
@@ -60,10 +62,28 @@ describe('[startup] Cli Utils (OS)', () => {
                 expect(subject(command)).rejects.toBeUndefined();
             })
         );
+
+        test('logs command and exit status', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject('foo');
+
+            expect(logInfoSpy).toHaveBeenCalledWith('run command foo');
+            expect(logInfoSpy).toHaveBeenCalledWith('command finished with code 0', 'foo');
+        });
+
+        test('quiet option suppresses output', async () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            await subject('foo', { quiet: true });
+
+            expect(logInfoSpy).not.toHaveBeenCalled();
+        });
     });
 
     describe(`${runCommandOutput.name}`, () => {
-        beforeEach(() => jest.mocked(execSync).mockReturnValue(''));
+        beforeEach(() => {
+            jest.clearAllMocks();
+            jest.mocked(execSync).mockReturnValue('');
+        });
 
         const subject = (...args: Parameters<typeof runCommandOutput>) => runCommandOutput(...args);
 
@@ -73,7 +93,7 @@ describe('[startup] Cli Utils (OS)', () => {
 
             expect(subject('foo bar')).toBe(result);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         test('runs command with options', () => {
@@ -85,13 +105,13 @@ describe('[startup] Cli Utils (OS)', () => {
         test('runs command array', () => {
             subject(['foo', 'bar']);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         test('ignores false and "" array values', () => {
             subject(['', 'foo', false, '', 'bar', false]);
 
-            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+            expect(execSync).toHaveBeenCalledWith('foo bar', {});
         });
 
         ['', [], ['']].forEach(command =>
@@ -99,5 +119,20 @@ describe('[startup] Cli Utils (OS)', () => {
                 expect(() => subject(command)).toThrow();
             })
         );
+
+        test('logs command and result', () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            subject('foo');
+
+            expect(logInfoSpy).toHaveBeenCalledWith('run command foo');
+            expect(logInfoSpy).toHaveBeenCalledWith('command finished', '');
+        });
+
+        test('quiet option suppresses output', () => {
+            const logInfoSpy = jest.spyOn(log, 'info');
+            subject('foo', { quiet: true });
+
+            expect(logInfoSpy).not.toHaveBeenCalled();
+        });
     });
 });

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

@@ -63,8 +63,12 @@ describe(`[startup] utils:${eslint.name}`, () => {
     });
 
     describe('when there are errors', () => {
+        const exitCode = process.exitCode;
+
         beforeEach(() => (eslintErrors = [mockResult]));
 
+        afterAll(() => (process.exitCode = exitCode));
+
         test('sets process exitCode', async () => {
             await subject();
 

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

@@ -5,10 +5,7 @@ import { stylesCopy, stylesCopyWatch } from '../styles-copy';
 import { styleExtensions } from '../index';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
+    copySync: jest.fn(),
     watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
 }));
 jest.mock('../../../utils', () => ({
@@ -28,10 +25,9 @@ describe('[startup] Cli Utils (Styles)', () => {
         test('copies styles from source to destination', async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
+            expect(cpx.copySync).toHaveBeenCalledWith(
                 `${source}/**/*.{${styleExtensions.join()}}`,
-                destination,
-                expect.anything()
+                destination
             );
         });
     });

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

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { assetExtensions } from '.';
 
-export async function assetsCopy() {
+export function assetsCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying asset files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${assetExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function assetsCopyWatch() {

package/src/cli/utils/cli-os.ts

@@ -6,9 +6,11 @@ import {
 } from 'child_process';
 import { log } from '../../utils';
 
+type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
+
 export const runCommand = (
     command: string | (string | false)[],
-    opts?: SpawnOptionsWithoutStdio
+    { quiet, ...spawnOptions }: RunCommandOptions = {}
 ): Promise<void> => {
     return new Promise((resolve, reject) => {
         const commandArray: string[] = Array.isArray(command)
@@ -28,15 +30,19 @@ export const runCommand = (
             return;
         }
 
-        log.info(`run command ${fullCommand}`);
+        if (!quiet) {
+            log.info(`run command ${fullCommand}`);
+        }
 
-        const proc = spawn(commandName, commandArray, opts);
+        const proc = spawn(commandName, commandArray, spawnOptions);
 
         proc.stdout.pipe(process.stdout);
         proc.stderr.pipe(process.stderr);
 
         proc.on('exit', function (code: any) {
-            log.info(`command finished with code ${code}`, fullCommand);
+            if (!quiet) {
+                log.info(`command finished with code ${code}`, fullCommand);
+            }
 
             if (code) {
                 reject();
@@ -47,9 +53,11 @@ export const runCommand = (
     });
 };
 
+type RunCommandOutputOptions = ExecSyncOptionsWithBufferEncoding & { quiet?: boolean };
+
 export const runCommandOutput = (
     command: string | (string | false)[],
-    options?: ExecSyncOptionsWithBufferEncoding
+    { quiet, ...execSyncOptions }: RunCommandOutputOptions = {}
 ): string => {
     const commandArray: string[] = Array.isArray(command)
         ? command
@@ -66,11 +74,15 @@ export const runCommandOutput = (
         throw new Error();
     }
 
-    log.info(`run command ${fullCommand}`);
+    if (!quiet) {
+        log.info(`run command ${fullCommand}`);
+    }
 
-    const result = execSync(fullCommand, options).toString();
+    const result = execSync(fullCommand, execSyncOptions).toString();
 
-    log.info('command finished', result);
+    if (!quiet) {
+        log.info('command finished', result);
+    }
 
     return result;
 };

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

@@ -1,15 +1,15 @@
 import cpx from 'cpx2';
-import util from 'util';
 
 import { getFolders, log } from '../../utils';
 import { styleExtensions } from '.';
 
-export async function stylesCopy() {
+export function stylesCopy() {
     const { source, destination } = getFolders();
 
     log.info('Copying style files...');
 
-    await util.promisify(cpx.copy)(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    cpx.copySync(`${source}/**/*.{${styleExtensions.join()}}`, destination);
+    return Promise.resolve();
 }
 
 export async function stylesCopyWatch() {

package/src/utils/__tests__/get-jest-config.test.ts

@@ -19,13 +19,6 @@ describe('[startup] Utils', () => {
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
-        transform: {
-            '^.+\\.jsx?$': [
-                'babel-jest',
-                { presets: [['@babel/preset-env', { targets: { node: 'current' } }]] },
-            ],
-            '^.+\\.tsx?$': ['ts-jest', { tsconfig: './tsconfig.test.json' }],
-        },
         moduleNameMapper: {
             '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
         },
@@ -34,6 +27,7 @@ describe('[startup] Utils', () => {
         coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         collectCoverageFrom: ['**/*.{ts,tsx}'],
+        preset: expect.stringMatching(/startup[\\\/]+jest/),
     };
 
     beforeEach(() => {

package/src/utils/__tests__/load-shared-dependencies.test.ts

@@ -1,10 +1,25 @@
 import { loadSharedDependencies } from '../load-shared-dependencies';
 
-describe('[Startup] utils:loadSharedDependencies', () => {
-    const getPackageDependencies = (...excluded: string[]) =>
-        Object.entries({
-            '@servicetitan/confirm': '^0.0.0',
+describe(`[startup] utils:${loadSharedDependencies.name}`, () => {
+    const defaultSharedDependencies = {
+        '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
+        '@servicetitan/anvil2': 'SharedDependencies.ServiceTitan.Anvil2',
+        'classnames': 'SharedDependencies.ClassNames',
+        'formstate': 'SharedDependencies.FormState',
+        'mobx': 'SharedDependencies.MobX',
+        'mobx-react': 'SharedDependencies.MobXReact',
+        'mobx-utils': 'SharedDependencies.MobXUtils',
+        'react': 'SharedDependencies.React',
+        'react-dom': 'SharedDependencies.ReactDOM',
+    };
+    let packageDependencies: Record<string, string> | undefined;
+    let sharedDependencies: Record<string, string> | undefined;
+
+    beforeEach(() => {
+        packageDependencies = {
+            // Default shared dependencies
             '@servicetitan/design-system': '^0.0.0',
+            '@servicetitan/anvil2': '^0.0.0',
             'classnames': '^0.0.0',
             'formstate': '^0.0.0',
             'mobx': '^0.0.0',
@@ -12,103 +27,82 @@ describe('[Startup] utils:loadSharedDependencies', () => {
             'mobx-utils': '^0.0.0',
             'react': '^0.0.0',
             'react-dom': '^0.0.0',
+            // Other dependencies
+            '@servicetitan/confirm': '^0.0.0',
             'react-input-mask': '^0.0.0',
-        }).reduce(
-            (out, [d, v]) => ({
-                ...out,
-                ...(excluded.includes(d) ? {} : { [d]: v }),
-            }),
-            {}
-        );
-
-    test('return default dependencies when manual are not configured', () => {
-        expect(loadSharedDependencies(getPackageDependencies(), undefined)).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'mobx-utils': 'SharedDependencies.MobXUtils',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-        });
+        };
+        sharedDependencies = undefined;
     });
 
-    test('return default dependencies except not used when manual are not configured', () => {
-        expect(loadSharedDependencies(getPackageDependencies('mobx-utils'), undefined)).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-        });
+    const subject = () => loadSharedDependencies(packageDependencies, sharedDependencies);
+
+    function omit(obj: Record<string, string>, ...exclude: string[]) {
+        return Object.fromEntries(Object.entries(obj).filter(([key]) => !exclude.includes(key)));
+    }
+
+    test('returns default shared dependencies', () => {
+        expect(subject()).toEqual(defaultSharedDependencies);
     });
 
-    test('return manual dependencies if set', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
-                'react-input-mask': 'SharedDependencies.ReactInputMask',
-            })
-        ).toEqual({
-            '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
-            'react-input-mask': 'SharedDependencies.ReactInputMask',
+    describe('when package does not depend on default shared dependency', () => {
+        beforeEach(() => delete packageDependencies!['@servicetitan/design-system']);
+
+        test('omits the default shared dependency', () => {
+            expect(subject()).toEqual(
+                omit(defaultSharedDependencies, '@servicetitan/design-system')
+            );
         });
     });
 
-    test('return default dependencies within manual', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                defaults: '',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'mobx-utils': 'SharedDependencies.MobXUtils',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
+    describe('with explicit shared dependencies', () => {
+        beforeEach(() => (sharedDependencies = {}));
+
+        test('returns specified dependencies', () => {
+            expect(subject()).toEqual(sharedDependencies);
         });
-    });
 
-    test('clear default dependencies when configured', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                'defaults': '',
-                'mobx-utils': '',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
+        describe('when explicit shared dependencies includes "defaults"', () => {
+            beforeEach(() => (sharedDependencies!.defaults = ''));
+
+            test('returns default shared dependencies', () => {
+                expect(subject()).toEqual(defaultSharedDependencies);
+            });
+
+            describe('when explicit shared dependency has falsy value', () => {
+                beforeEach(() => {
+                    Object.assign(sharedDependencies!, { 'classnames': false, 'mobx-utils': '' });
+                });
+
+                test('omits the falsy dependency', () => {
+                    expect(subject()).toEqual(
+                        omit(defaultSharedDependencies, 'classnames', 'mobx-utils')
+                    );
+                });
+            });
+
+            describe('when explicit shared dependency has non-default packages', () => {
+                beforeEach(() => {
+                    Object.assign(sharedDependencies!, {
+                        '@servicetitan/confirm': 'SharedDependencies.ServiceTitan.Confirm',
+                        'react-input-mask': 'SharedDependencies.ReactInputMask',
+                    });
+                });
+
+                test('adds the non-default packages', () => {
+                    expect(subject()).toEqual({
+                        ...defaultSharedDependencies,
+                        ...omit(sharedDependencies!, 'defaults'),
+                    });
+                });
+            });
         });
     });
 
-    test('mixes default dependencies and configured', () => {
-        expect(
-            loadSharedDependencies(getPackageDependencies(), {
-                'defaults': '',
-                'mobx-utils': '',
-                'react-input-mask': 'SharedDependencies.ReactInputMask',
-                'react-something': 'SharedDependencies.ReactSomething',
-            })
-        ).toEqual({
-            '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
-            'classnames': 'SharedDependencies.ClassNames',
-            'formstate': 'SharedDependencies.FormState',
-            'mobx': 'SharedDependencies.MobX',
-            'mobx-react': 'SharedDependencies.MobXReact',
-            'react': 'SharedDependencies.React',
-            'react-dom': 'SharedDependencies.ReactDOM',
-            'react-input-mask': 'SharedDependencies.ReactInputMask',
+    describe('with no package dependencies', () => {
+        beforeEach(() => (packageDependencies = undefined));
+
+        test('returns empty object', () => {
+            expect(subject()).toEqual({});
         });
     });
 });

package/src/utils/get-folders.ts

@@ -1,6 +1,6 @@
 import path from 'path';
 
-import { readJson } from '.';
+import { readJson } from './read-json';
 
 /**
  * Returns folders of sources and compilation target

package/src/utils/get-jest-config.ts

@@ -13,13 +13,6 @@ const getJestConfigBase = ({
     setupFiles?: string[];
     testPathIgnorePatterns?: string[];
 }) => {
-    const transform = {
-        '^.+\\.jsx?$': [
-            'babel-jest',
-            { presets: [['@babel/preset-env', { targets: { node: 'current' } }]] },
-        ],
-        '^.+\\.tsx?$': ['ts-jest', { tsconfig: './tsconfig.test.json' }],
-    };
     const moduleNameMapper = {
         '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
     };
@@ -30,7 +23,6 @@ const getJestConfigBase = ({
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
-        transform,
         moduleNameMapper,
         testPathIgnorePatterns: [
             '\\.yalc',
@@ -41,6 +33,7 @@ const getJestConfigBase = ({
         coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         collectCoverageFrom: ['**/*.{ts,tsx}'],
+        preset: path.join(__dirname, '../../jest'),
     };
 };
 
@@ -70,7 +63,7 @@ export const getJestConfigCLI = (args: Config.Argv): Config.Argv => {
         ...args,
     };
 
-    const { collectCoverageFrom, moduleNameMapper, transform, ...rest } = getJestConfigBase({
+    const { collectCoverageFrom, moduleNameMapper, ...rest } = getJestConfigBase({
         coveragePathIgnorePatterns,
         setupFiles,
         testPathIgnorePatterns,
@@ -80,7 +73,6 @@ export const getJestConfigCLI = (args: Config.Argv): Config.Argv => {
         collectCoverageFrom: JSON.stringify(collectCoverageFrom),
         globals: JSON.stringify(globals),
         moduleNameMapper: JSON.stringify(moduleNameMapper),
-        transform: JSON.stringify(transform),
         ...rest,
         ...config,
     };

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -33,7 +33,6 @@ jest.mock('../../utils', () => ({
     isCustomStyleRules: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
     loadSharedDependencies: jest.fn(),
-    log: { debug: jest.fn(), info: jest.fn() },
 }));
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),