@servicetitan/startup 30.3.1 → 31.1.0

package/src/utils/__tests__/get-packages.test.ts

@@ -1,12 +1,6 @@
 import path from 'path';
 import { fs, vol } from 'memfs';
-import {
-    Package,
-    PackageType,
-    getPackages,
-    getPackagesGraph,
-    splitPackagesByType,
-} from '../get-packages';
+import { PackageType, getPackages, getPackagesGraph } from '../get-packages';
 
 jest.mock('fs', () => fs);
 
@@ -48,6 +42,13 @@ describe('[startup] Utils', () => {
                             cli: { webpack: false },
                         }),
                     },
+                    qux: {
+                        'package.json': JSON.stringify({
+                            name: 'qux',
+                            version: '4.0.0',
+                            cli: { webpack: false },
+                        }),
+                    },
                 },
             });
         });
@@ -80,9 +81,35 @@ describe('[startup] Utils', () => {
                     location: path.resolve('./examples/baz'),
                     type: PackageType.TSC,
                 },
+                {
+                    name: 'qux',
+                    version: '4.0.0',
+                    private: false,
+                    location: path.resolve('./examples/qux'),
+                    type: PackageType.TSC,
+                },
             ]);
         });
 
+        describe('when workspaces excludes package', () => {
+            beforeEach(() => {
+                const packageJSON = JSON.parse(fs.readFileSync('package.json', 'utf8').toString());
+                fs.writeFileSync(
+                    'package.json',
+                    JSON.stringify({
+                        ...packageJSON,
+                        workspaces: [...packageJSON.workspaces, '!examples/baz'],
+                    })
+                );
+            });
+
+            test('omits excluded package', () => {
+                expect(subject()).toEqual(
+                    ['foo', 'bar', 'qux'].map(name => expect.objectContaining({ name }))
+                );
+            });
+        });
+
         describe('with "scope"', () => {
             beforeEach(() => (options = { scope: 'foo' }));
 
@@ -101,10 +128,9 @@ describe('[startup] Utils', () => {
                 });
 
                 test('also returns internal dependencies', () => {
-                    expect(subject()).toEqual([
-                        expect.objectContaining({ name: 'foo' }),
-                        expect.objectContaining({ name: 'bar' }),
-                    ]);
+                    expect(subject()).toEqual(
+                        ['foo', 'bar'].map(name => expect.objectContaining({ name }))
+                    );
                 });
             });
 
@@ -112,10 +138,9 @@ describe('[startup] Utils', () => {
                 beforeEach(() => (options = { scope: 'ba*' }));
 
                 test('returns only the specified packages', () => {
-                    expect(subject()).toEqual([
-                        expect.objectContaining({ name: 'bar' }),
-                        expect.objectContaining({ name: 'baz' }),
-                    ]);
+                    expect(subject()).toEqual(
+                        ['bar', 'baz'].map(name => expect.objectContaining({ name }))
+                    );
                 });
             });
         });
@@ -138,6 +163,24 @@ describe('[startup] Utils', () => {
             });
         });
 
+        describe('with "type"', () => {
+            beforeEach(() => (options = { type: PackageType.Webpack }));
+
+            test('returns only the specified packages', () => {
+                expect(subject()).toEqual([expect.objectContaining({ name: 'foo' })]);
+            });
+
+            describe('when "type" is an array', () => {
+                beforeEach(() => (options = { type: [PackageType.TSC, PackageType.Webpack] }));
+
+                test('returns only the specified packages', () => {
+                    expect(subject()).toEqual(
+                        ['foo', 'baz', 'qux'].map(name => expect.objectContaining({ name }))
+                    );
+                });
+            });
+        });
+
         function itReturnsEmptyArray() {
             test('returns empty array', () => {
                 expect(subject()).toEqual([]);
@@ -216,38 +259,4 @@ describe('[startup] Utils', () => {
             });
         });
     });
-
-    describe(`${splitPackagesByType.name}`, () => {
-        const packages: Pick<Package, 'name' | 'location' | 'type'>[] = [
-            { name: 'foo', location: 'packages/foo', type: PackageType.Legacy },
-            { name: 'bar', location: 'packages/bar', type: PackageType.TSC },
-            { name: 'baz', location: 'packages/baz', type: PackageType.Webpack },
-        ];
-
-        const subject = (packages: Package[]) => splitPackagesByType(packages);
-
-        test('groups packages by type', () => {
-            expect(subject(packages as Package[])).toEqual(
-                packages.reduce<ReturnType<typeof splitPackagesByType>>(
-                    (result, pkg) => {
-                        result[pkg.type].push(pkg as Package);
-                        return result;
-                    },
-                    {
-                        [PackageType.TSC]: [],
-                        [PackageType.Webpack]: [],
-                        [PackageType.Legacy]: [],
-                    }
-                )
-            );
-        });
-
-        test('grouping always includes all types', () => {
-            expect(subject([])).toEqual({
-                [PackageType.TSC]: [],
-                [PackageType.Webpack]: [],
-                [PackageType.Legacy]: [],
-            });
-        });
-    });
 });

package/src/utils/__tests__/log-errors.test.ts

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/only-throw-error */
+import { log } from '../log';
+import { logErrors } from '../log-errors';
+
+describe(`[startup] Utils`, () => {
+    describe(`${logErrors.name}`, () => {
+        let error: Error | undefined;
+
+        beforeEach(() => (error = new Error('Oops!')));
+
+        class SubjectClass {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            private _foo: boolean;
+
+            constructor() {
+                this._foo = false;
+            }
+
+            @logErrors
+            execute(callback: Function) {
+                return callback();
+            }
+
+            @logErrors
+            async executeAsync(callback: Function) {
+                await callback();
+            }
+
+            @logErrors
+            get foo() {
+                throw error;
+            }
+
+            set foo(value: boolean) {
+                this._foo = value;
+            }
+        }
+
+        const instance = new SubjectClass();
+
+        beforeEach(() => {
+            jest.resetAllMocks();
+            jest.spyOn(log, 'error').mockImplementation(jest.fn());
+        });
+
+        describe('when decorated function raises no error', () => {
+            const subject = () => instance.execute(jest.fn());
+
+            test('logs nothing', () => {
+                subject();
+
+                expect(log.error).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('when decorated function throws error', () => {
+            const subject = () =>
+                instance.execute(() => {
+                    throw error;
+                });
+
+            test('logs error', () => {
+                expect(subject).toThrow(error);
+
+                expect(log.error).toHaveBeenCalledWith(String(error));
+            });
+        });
+
+        describe('when decorated asynchronous function rejects', () => {
+            const subject = async () =>
+                instance.executeAsync(() => {
+                    throw error;
+                });
+
+            test('logs error', async () => {
+                await expect(subject).rejects.toThrow(error);
+
+                expect(log.error).toHaveBeenCalledWith(String(error));
+            });
+
+            describe('when function rejects with undefined', () => {
+                beforeEach(() => (error = undefined));
+
+                test('does not log error', async () => {
+                    await expect(subject).rejects.toBe(undefined);
+
+                    expect(log.error).not.toHaveBeenCalled();
+                });
+            });
+        });
+
+        describe('when decorated accessor throws error', () => {
+            const subject = () => instance.foo;
+
+            test('logs nothing', () => {
+                expect(subject).toThrow(error);
+
+                expect(log.error).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

package/src/utils/__tests__/log.test.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { log, logErrors } from '../log';
+import { log } from '../log';
 import { createDebug } from '../debug';
 
 jest.mock('../debug');
@@ -83,89 +83,4 @@ describe(`[startup] Utils`, () => {
             });
         });
     });
-
-    describe(`${logErrors.name}`, () => {
-        const error = new Error('Oops!');
-
-        class SubjectClass {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            private _foo: boolean;
-
-            constructor() {
-                this._foo = false;
-            }
-
-            @logErrors
-            execute(callback: Function) {
-                return callback();
-            }
-
-            @logErrors
-            async executeAsync(callback: Function) {
-                await callback();
-            }
-
-            @logErrors
-            get foo() {
-                throw error;
-            }
-
-            set foo(value: boolean) {
-                this._foo = value;
-            }
-        }
-
-        const instance = new SubjectClass();
-
-        beforeEach(() => {
-            jest.resetAllMocks();
-            jest.spyOn(log, 'error').mockImplementation(jest.fn());
-        });
-
-        describe('when decorated function raises no error', () => {
-            const subject = () => instance.execute(jest.fn());
-
-            test('logs nothing', () => {
-                subject();
-
-                expect(log.error).not.toHaveBeenCalled();
-            });
-        });
-
-        describe('when decorated function throws error', () => {
-            const subject = () =>
-                instance.execute(() => {
-                    throw error;
-                });
-
-            test('logs error', () => {
-                expect(subject).toThrow(error);
-
-                expect(log.error).toHaveBeenCalledWith(String(error));
-            });
-        });
-
-        describe('when decorated asynchronous function throws error', () => {
-            const subject = async () =>
-                instance.executeAsync(() => {
-                    throw error;
-                });
-
-            test('logs error', async () => {
-                await expect(subject).rejects.toThrow(error);
-
-                expect(log.error).toHaveBeenCalledWith(String(error));
-            });
-        });
-
-        describe('when decorated accessor throws error', () => {
-            const subject = () => instance.foo;
-
-            test('logs nothing', () => {
-                expect(subject).toThrow(error);
-
-                expect(log.error).not.toHaveBeenCalled();
-            });
-        });
-    });
 });

package/src/utils/find-packages.ts

@@ -1,4 +1,5 @@
 import { globSync } from 'glob';
+import multimatch from 'multimatch';
 import path from 'path';
 import { readJsonSafe } from './read-json';
 import { log } from './log';
@@ -14,8 +15,10 @@ export function findPackages(): ProjectPackage[] {
         return [];
     }
 
-    const result = workspaces
-        .flatMap(pattern => globSync(pattern))
+    const result = multimatch(
+        workspaces.flatMap(pattern => globSync(pattern)),
+        workspaces
+    )
         .map(location => {
             const dir = path.resolve(location);
             const file = path.join(dir, 'package.json');
@@ -25,7 +28,7 @@ export function findPackages(): ProjectPackage[] {
 
     /* istanbul ignore next: debug only */
     log.debug(
-        `find-packages`,
+        'find-packages',
         () => `found packages: ${JSON.stringify(result.map(({ name }) => name))}`
     );
 
@@ -47,10 +50,13 @@ function findWorkspaces() {
         }
 
         if (workspaces) {
-            workspaces = workspaces.map(
+            workspaces = workspaces.map(workspace => {
+                const result = workspace.startsWith('!')
+                    ? `!${path.join(directory, workspace.slice(1))}`
+                    : path.join(directory, workspace);
                 // Note, glob requires "/" as path separator, even on Windows
-                workspace => path.join(directory, workspace).replace(/\\/g, '/')
-            );
+                return result.replace(/\\/g, '/');
+            });
             /* istanbul ignore next: debug only */
             log.debug('find-packages', () => `found workspaces: ${JSON.stringify(workspaces)}`);
             return workspaces;

package/src/utils/format-duration.ts

@@ -0,0 +1,13 @@
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+
+export function formatDuration(duration: number) {
+    if (duration < SECOND) {
+        return `${duration.toFixed(0)}ms`;
+    } else if (duration < MINUTE) {
+        return `${(duration / SECOND).toFixed(2)}s`;
+    }
+    const minutes = Math.floor(duration / MINUTE);
+    const seconds = Math.round((duration - minutes * MINUTE) / SECOND);
+    return `${minutes}m ${seconds}s`;
+}

package/src/utils/get-configuration.ts

@@ -1,12 +1,15 @@
+import { Config } from '@jest/types';
+import { swcDir } from '@swc/cli';
+import { ESLint } from 'eslint';
 import fs from 'fs';
 import path from 'path';
-
-import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
-import { ESLint } from 'eslint';
 import { LinterOptions } from 'stylelint';
-import { Config } from '@jest/types';
-import { readJson, readJsonSafe } from './read-json';
+import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
+
+import { ReviewConfiguration } from '../cli/commands/review';
 import { log } from './log';
+import { getFolders } from './get-folders';
+import { readJson, readJsonSafe } from './read-json';
 
 export const allowedWebpackDevServerOptions = ['headers', 'port', 'proxy', 'static'] as const;
 
@@ -58,6 +61,7 @@ export interface NodeConfiguration {
 export enum CommandName {
     'build' = 'build',
     'bundle-package' = 'bundle-package',
+    'clean' = 'clean',
     'convert-eslint-config' = 'convert-eslint-config',
     'eslint' = 'eslint',
     'init' = 'init',
@@ -68,6 +72,7 @@ export enum CommandName {
     'mfe-package-publish' = 'mfe-package-publish',
     'mfe-publish' = 'mfe-publish',
     'prepare-package' = 'prepare-package',
+    'review' = 'review',
     'start' = 'start',
     'styles-check' = 'styles-check',
     'test' = 'test',
@@ -91,6 +96,8 @@ interface WebComponentOptions {
 type Configuration = {
     'legacy'?: boolean;
     'lint'?: { eslint: ESLintConfiguration; stylelint: StylelintConfiguration };
+    'review'?: ReviewConfiguration;
+    'swc-compile-package'?: Parameters<typeof swcDir>[0];
     'test'?: JestConfiguration;
     'web-component'?: boolean | string | WebComponentOptions;
     'webpack'?: false | WebpackConfiguration;
@@ -124,6 +131,10 @@ export function getJestConfiguration() {
     return getConfiguration().test ?? {};
 }
 
+export function getReviewConfiguration() {
+    return getConfiguration().review ?? {};
+}
+
 export function getStylelintConfiguration() {
     return getConfiguration().lint?.stylelint ?? {};
 }
@@ -165,6 +176,21 @@ export function getWebComponentBranchConfigs(locationOrJson: LocationOrJson = '.
     return config?.branches;
 }
 
+export function hasHeadlessBundle() {
+    let source: string;
+    try {
+        source = getFolders().source;
+    } catch {
+        return false;
+    }
+    const headlessPath = path.join(source, 'headless.ts');
+    return fs.existsSync(headlessPath);
+}
+
+export function getSwcCompilePackageConfiguration() {
+    return getConfiguration()['swc-compile-package'] ?? {};
+}
+
 export function isBundle(locationOrJson?: LocationOrJson) {
     return getConfiguration(locationOrJson).webpack !== false;
 }

package/src/utils/get-folders.ts

@@ -7,7 +7,9 @@ import { readJson } from './read-json';
  */
 export function getFolders(location = './') {
     const { rootDir, outDir } =
-        readJson(path.join(location, 'tsconfig.json')).compilerOptions ?? {};
+        readJson<{ compilerOptions: { rootDir?: string; outDir?: string } }>(
+            path.join(location, 'tsconfig.json')
+        ).compilerOptions ?? {};
 
     if (!rootDir) {
         throw new Error('"compilerOptions.rootDir" must be defined in the "tsconfig.json"!');

package/src/utils/get-packages.ts

@@ -20,14 +20,16 @@ export interface Package {
 interface GetPackagesOptions {
     scope?: string | string[];
     ignore?: string | string[];
+    type?: PackageType | PackageType[];
 }
 
 export function getPackages(options: GetPackagesOptions = {}) {
     const scope = toArray(options.scope);
     const ignore = toArray(options.ignore);
+    const type = toArray(options.type);
 
     const allPackages = findPackages();
-    if (scope.length === 0 && ignore.length === 0) {
+    if (scope.length === 0 && ignore.length === 0 && type.length === 0) {
         return withMetadata(allPackages);
     }
 
@@ -59,7 +61,12 @@ export function getPackages(options: GetPackagesOptions = {}) {
         }
     }
 
-    return withMetadata(allPackages.filter(({ name }) => used[name]));
+    let result = withMetadata(allPackages.filter(({ name }) => used[name]));
+    if (type.length > 0) {
+        result = result.filter(pkg => type.includes(pkg.type));
+    }
+
+    return result;
 }
 
 /**
@@ -129,20 +136,6 @@ function getPackageType(packageJson: ProjectPackage) {
     return PackageType.TSC;
 }
 
-export function splitPackagesByType(packages: Package[]) {
-    const result: Record<PackageType, Package[]> = {
-        [PackageType.TSC]: [],
-        [PackageType.Webpack]: [],
-        [PackageType.Legacy]: [],
-    };
-
-    for (const pkg of packages) {
-        result[pkg.type].push(pkg);
-    }
-
-    return result;
-}
-
 function negate(patterns: string[]) {
     return patterns.map(pattern => `!${pattern}`);
 }

package/src/utils/index.ts

@@ -1,3 +1,5 @@
+export * from './find-packages';
+export * from './format-duration';
 export * from './get-configuration';
 export * from './get-destination-folders';
 export * from './get-folders';
@@ -9,6 +11,7 @@ export * from './get-startup-version';
 export * from './get-tsconfig';
 export * from './load-shared-dependencies';
 export * from './log';
+export * from './log-errors';
 export * from './pick';
 export * from './read-json';
 export * from './to-array';

package/src/utils/log-errors.ts

@@ -0,0 +1,29 @@
+import { log } from './log';
+
+export function logErrors(_0: any, _1: string, descriptor: PropertyDescriptor) {
+    const origin = descriptor.value;
+
+    if (typeof origin !== 'function') {
+        return;
+    }
+
+    descriptor.value = function (...args: any[]) {
+        try {
+            const result = origin.apply(this, args);
+
+            if (result instanceof Promise) {
+                return result.catch(e => {
+                    if (e !== undefined) {
+                        log.error(String(e));
+                    }
+                    throw e;
+                });
+            }
+
+            return result;
+        } catch (e) {
+            log.error(String(e));
+            throw e;
+        }
+    };
+}

package/src/utils/log.ts

@@ -45,29 +45,3 @@ class Log {
 }
 
 export const log = new Log();
-
-export function logErrors(_0: any, _1: string, descriptor: PropertyDescriptor) {
-    const origin = descriptor.value;
-
-    if (typeof origin !== 'function') {
-        return;
-    }
-
-    descriptor.value = function (...args: any[]) {
-        try {
-            const result = origin.apply(this, args);
-
-            if (result instanceof Promise) {
-                return result.catch(e => {
-                    log.error(String(e));
-                    throw e;
-                });
-            }
-
-            return result;
-        } catch (e) {
-            log.error(String(e));
-            throw e;
-        }
-    };
-}

package/src/webpack/__mocks__/file-rules.ts

@@ -70,9 +70,4 @@ export const fileRules: Record<string, RuleSetRule> = {
             filename: 'images/[contenthash][ext][query]',
         },
     },
-    '.tsx': {
-        test: /\.tsx?$/,
-        exclude: /node_modules/,
-        use: [{ loader: 'ts-loader', options: { transpileOnly: true } }],
-    },
 };

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

@@ -38,7 +38,6 @@ jest.mock('../../utils', () => ({
 jest.mock('../configs/utils/get-launchdarkly-sdk-version');
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
-    featureCohort: jest.fn(),
     getCallerFile: jest.fn(),
     getModuleEntryPath: jest.fn(),
 }));