@servicetitan/startup 22.17.0 → 22.19.0

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

@@ -1,4 +1,3 @@
-import fs from 'fs';
 import mockFS from 'mock-fs';
 import path from 'path';
 import webpack from 'webpack';
@@ -44,45 +43,36 @@ describe('[startup] Cli Utils', () => {
         return expect.stringContaining(name);
     }
 
-    function generatedMetadata(destination: string) {
-        return JSON.parse(fs.readFileSync(`${destination}/metadata.json`, 'utf8'));
-    }
-
     function packageFS() {
         return { 'package.json': JSON.stringify(pkg) };
     }
 
-    function webComponentFS(startupVersion: string) {
-        return {
-            'package.json': JSON.stringify({ ...pkg, cli: { 'web-component': true } }),
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            'node_modules': {
-                '@servicetitan': {
-                    'package.json': JSON.stringify({ version: startupVersion }),
-                    'startup': { 'index.js': '' },
-                },
-            },
-        };
+    function webComponentFS() {
+        return { 'package.json': JSON.stringify({ ...pkg, cli: { 'web-component': true } }) };
     }
 
     describe(`${bundle.name}`, () => {
-        const customProdConfig = { configuration: { foo: 'bar' }, plugins: { baz: 'qux' } };
+        const prodConfig = { configuration: { foo: 'bar' }, plugins: { baz: 'qux' } };
+        const customConfig = { configuration: { baz: 'qux' }, plugins: { foo: 'bar' } };
+        const customConfigFileName = 'custom.prod.config.js';
         const stats: Partial<webpack.Stats> = { hasErrors: () => false, toString: () => 'foo' };
-        let buildStat: boolean;
+
+        let options: Parameters<typeof bundle>[0];
         let stdoutSpy: jest.SpyInstance;
 
         beforeEach(() => {
             mockFS(packageFS());
+            options = { buildStat: false };
+            stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+            compiler.run = jest.fn(callback => callback(null, stats as any));
             // Allows config file to be loaded with require(...)
-            jest.doMock(path.resolve(webpackProdConfigFileName), () => customProdConfig, {
+            jest.doMock(path.resolve(webpackProdConfigFileName), () => prodConfig, {
                 virtual: true,
             });
-            buildStat = false;
-            stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
-            compiler.run = jest.fn(callback => callback(null, stats as any));
+            jest.doMock(path.resolve(customConfigFileName), () => customConfig, { virtual: true });
         });
 
-        const subject = async () => bundle(buildStat);
+        const subject = async () => bundle(options);
 
         test('runs webpack and outputs stats', async () => {
             const toStringSpy = jest.spyOn(stats, 'toString');
@@ -91,7 +81,7 @@ describe('[startup] Cli Utils', () => {
 
             expect(createWebpackConfig).toHaveBeenCalledWith(
                 { configuration: { mode: 'production' } },
-                { buildStat, name: expectPackageName() }
+                { buildStat: options?.buildStat, name: expectPackageName() }
             );
             expect(webpack).toHaveBeenCalledWith(createWebpackResult);
             expect(compiler.run).toHaveBeenCalled();
@@ -137,99 +127,105 @@ describe('[startup] Cli Utils', () => {
             });
         });
 
+        function itUsesConfig(params: { config: () => Record<string, any>; name: string }) {
+            test(`uses ${params.name}`, async () => {
+                await subject();
+
+                expect(webpack).toHaveBeenCalledWith(params.config());
+            });
+        }
+
         describe(`with ${webpackProdConfigFileName} config`, () => {
-            beforeEach(() => mockFS({ ...packageFS(), [webpackProdConfigFileName]: '' }));
+            const FS = { ...packageFS(), [webpackProdConfigFileName]: '' };
 
-            test('uses config', async () => {
-                await subject();
+            beforeEach(() => mockFS(FS));
+
+            itUsesConfig({ name: webpackProdConfigFileName, config: () => prodConfig });
+
+            describe('with custom config', () => {
+                beforeEach(() => {
+                    options = { config: customConfigFileName };
+                    mockFS({ ...FS, [customConfigFileName]: '' });
+                });
 
-                expect(webpack).toHaveBeenCalledWith(customProdConfig);
+                itUsesConfig({ name: 'custom config', config: () => customConfig });
+
+                describe('when custom config file does not exist', () => {
+                    beforeEach(() => (options!.config = 'bogus.config.js'));
+
+                    itUsesConfig({ name: webpackProdConfigFileName, config: () => prodConfig });
+                });
             });
         });
 
         describe('when package is a web component', () => {
             const source = 'src';
             const destination = 'dist';
-            const startupVersion = '1.0.0';
             const dependencies = { foo: '1.0.1' };
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
-                mockFS(webComponentFS(startupVersion));
+                mockFS(webComponentFS());
                 jest.mocked(getFolders).mockReturnValue({ source, destination });
                 jest.mocked(getPackageData).mockReturnValue({ dependencies });
                 jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
             });
 
             test('builds full and "embed" packages', async () => {
-                const options = { buildStat, name: expectPackageName() };
+                const createOptions = { buildStat: options?.buildStat, name: expectPackageName() };
                 const overrides = { configuration: { mode: 'production' } };
 
                 await subject();
 
-                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, createOptions);
                 expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
-                    ...options,
+                    ...createOptions,
                     embed: true,
                 });
                 expect(compiler.run).toHaveBeenCalledTimes(2);
             });
 
-            test('generates package metadata', async () => {
-                await subject();
-
-                expect(generatedMetadata(destination)).toEqual({
-                    name: expectPackageName(),
-                    bundledWith: { '@servicetitan/startup': startupVersion },
-                    dependencies,
-                    sharedDependencies,
-                    entrypoints: {},
-                });
-            });
+            function itUsesConfig(params: { config: () => Record<string, any>; name: string }) {
+                test(`uses ${params.name}`, async () => {
+                    const { configuration, plugins } = params.config();
+                    const createOptions = {
+                        buildStat: options?.buildStat,
+                        name: expectPackageName(),
+                    };
+                    const overrides = {
+                        configuration: { mode: 'production', ...configuration },
+                        plugins,
+                    };
 
-            describe('when package has entrypoints', () => {
-                const full = { css: 'foo', js: 'bar ' };
-                const light = { css: 'baz', js: 'qux' };
+                    await subject();
 
-                beforeEach(() => {
-                    mockFS({
-                        ...webComponentFS(startupVersion),
-                        dist: {
-                            bundle: {
-                                full: { 'entrypoints.json': JSON.stringify(full) },
-                                light: { 'entrypoints.json': JSON.stringify(light) },
-                            },
-                        },
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, createOptions);
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                        ...createOptions,
+                        embed: true,
                     });
                 });
+            }
 
-                test('adds entrypoints to package metadata', async () => {
-                    await subject();
+            describe(`with ${webpackProdConfigFileName} config`, () => {
+                const FS = { ...webComponentFS(), [webpackProdConfigFileName]: '' };
 
-                    expect(generatedMetadata(destination)).toEqual(
-                        expect.objectContaining({ entrypoints: { full, light } })
-                    );
-                });
-            });
+                beforeEach(() => mockFS(FS));
 
-            describe(`with ${webpackProdConfigFileName} config`, () => {
-                beforeEach(() => {
-                    mockFS({ ...webComponentFS(startupVersion), [webpackProdConfigFileName]: '' });
-                });
+                itUsesConfig({ name: webpackProdConfigFileName, config: () => prodConfig });
 
-                test('uses config', async () => {
-                    const options = { buildStat, name: expectPackageName() };
-                    const overrides = {
-                        configuration: { mode: 'production', ...customProdConfig.configuration },
-                        plugins: customProdConfig.plugins,
-                    };
+                describe('with custom config', () => {
+                    beforeEach(() => {
+                        options = { config: customConfigFileName };
+                        mockFS({ ...FS, [customConfigFileName]: '' });
+                    });
 
-                    await subject();
+                    itUsesConfig({ name: 'custom config', config: () => customConfig });
 
-                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
-                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
-                        ...options,
-                        embed: true,
+                    describe('when custom config file does not exist', () => {
+                        beforeEach(() => (options!.config = 'bogus.config.js'));
+
+                        itUsesConfig({ name: webpackProdConfigFileName, config: () => prodConfig });
                     });
                 });
             });
@@ -237,22 +233,26 @@ describe('[startup] Cli Utils', () => {
     });
 
     describe(`${bundleWatch.name}`, () => {
-        const customDevConfig = {
+        const devConfig = {
             devServer: { host: 'http://127.0.0.0', port: '9000' },
             configuration: { foo: 'bar' },
             plugins: { baz: 'qux' },
         };
+        const customConfig = {
+            devServer: { port: 9009 },
+            configuration: { baz: 'qux' },
+            plugins: { foo: 'bar' },
+        };
+        const customConfigFileName = 'custom.dev.config.js';
+        let options: Parameters<typeof bundle>[0];
 
         function stopWatching(callback?: Function) {
             setTimeout(() => callback?.(new Error('stopped')), 0);
         }
 
         beforeEach(() => {
+            options = undefined;
             mockFS(packageFS());
-            // Allows config file to be loaded with require(...)
-            jest.doMock(path.resolve(webpackDevConfigFileName), () => customDevConfig, {
-                virtual: true,
-            });
             jest.mocked(WebpackDevServer).mockImplementation((): any => ({
                 listen: jest.fn((_0: number, _1: string, callback?: (error?: Error) => void) =>
                     stopWatching(callback)
@@ -263,10 +263,13 @@ describe('[startup] Cli Utils', () => {
                 stopWatching(callback);
                 return { compiler, close: compiler.close };
             });
+            // Allows config files to be loaded with require(...)
+            jest.doMock(path.resolve(customConfigFileName), () => customConfig, { virtual: true });
+            jest.doMock(path.resolve(webpackDevConfigFileName), () => devConfig, { virtual: true });
         });
 
         const subject = async () => {
-            await expect(bundleWatch()).rejects.toThrowError('stopped');
+            await expect(bundleWatch(options)).rejects.toThrowError('stopped');
         };
 
         test('runs webpack development server', async () => {
@@ -280,45 +283,53 @@ describe('[startup] Cli Utils', () => {
             expect(WebpackDevServer).toHaveBeenCalledWith(compiler, {});
         });
 
-        describe(`with ${webpackDevConfigFileName} config`, () => {
-            beforeEach(() => mockFS({ ...packageFS(), [webpackDevConfigFileName]: '' }));
-
-            test('uses config', async () => {
-                const { devServer, ...config } = customDevConfig;
+        function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
+            test(`uses ${params.name}`, async () => {
+                const { devServer, ...config } = params.config();
 
                 await subject();
 
                 expect(webpack).toHaveBeenCalledWith(config);
                 expect(WebpackDevServer).toHaveBeenCalledWith(compiler, devServer);
             });
+        }
+
+        describe(`with ${webpackDevConfigFileName} config`, () => {
+            const FS = { ...packageFS(), [webpackDevConfigFileName]: '' };
+
+            beforeEach(() => mockFS(FS));
+
+            itUsesConfig({ name: webpackDevConfigFileName, config: () => devConfig });
+
+            describe('with custom config', () => {
+                beforeEach(() => {
+                    options = { config: customConfigFileName };
+                    mockFS({ ...FS, [customConfigFileName]: '' });
+                });
+
+                itUsesConfig({ name: 'custom config', config: () => customConfig });
+
+                describe('when custom config does not exist', () => {
+                    beforeEach(() => (options!.config = 'bogus.config.js'));
+
+                    itUsesConfig({ name: webpackDevConfigFileName, config: () => devConfig });
+                });
+            });
         });
 
         describe('when package is a web component', () => {
             const source = 'src';
             const destination = 'dist';
-            const startupVersion = '1.0.0';
             const dependencies = { foo: '1.0.1' };
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
-                mockFS(webComponentFS(startupVersion));
+                mockFS(webComponentFS());
                 jest.mocked(getFolders).mockReturnValue({ source, destination });
                 jest.mocked(getPackageData).mockReturnValue({ dependencies });
                 jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
             });
 
-            test('generates package metadata', async () => {
-                await subject();
-
-                expect(generatedMetadata(destination)).toEqual({
-                    name: expectPackageName(),
-                    bundledWith: { '@servicetitan/startup': startupVersion },
-                    dependencies,
-                    sharedDependencies,
-                    entrypoints: {},
-                });
-            });
-
             test('runs webpack and webpack development server', async () => {
                 const options = { name: expectPackageName() };
                 const overrides = { configuration: { mode: 'development' } };
@@ -335,16 +346,13 @@ describe('[startup] Cli Utils', () => {
                 expect(WebpackDevServer).toHaveBeenCalledWith(compiler, {});
             });
 
-            describe(`with ${webpackDevConfigFileName} config`, () => {
-                beforeEach(() => {
-                    mockFS({ ...webComponentFS(startupVersion), [webpackDevConfigFileName]: '' });
-                });
-
-                test('uses config', async () => {
+            function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
+                test(`uses ${params.name}`, async () => {
                     const options = { name: expectPackageName() };
+                    const { configuration, plugins } = params.config();
                     const overrides = {
-                        configuration: { mode: 'development', ...customDevConfig.configuration },
-                        plugins: customDevConfig.plugins,
+                        configuration: { mode: 'development', ...configuration },
+                        plugins,
                     };
 
                     await subject();
@@ -355,6 +363,29 @@ describe('[startup] Cli Utils', () => {
                         embed: true,
                     });
                 });
+            }
+
+            describe(`with ${webpackDevConfigFileName} config`, () => {
+                const FS = { ...webComponentFS(), [webpackDevConfigFileName]: '' };
+
+                beforeEach(() => mockFS(FS));
+
+                itUsesConfig({ name: webpackDevConfigFileName, config: () => devConfig });
+
+                describe('with custom config', () => {
+                    beforeEach(() => {
+                        options = { config: customConfigFileName };
+                        mockFS({ ...FS, [customConfigFileName]: '' });
+                    });
+
+                    itUsesConfig({ name: 'custom config', config: () => customConfig });
+
+                    describe('when custom config does not exist', () => {
+                        beforeEach(() => (options!.config = 'bogus.config.js'));
+
+                        itUsesConfig({ name: webpackDevConfigFileName, config: () => devConfig });
+                    });
+                });
             });
         });
     });

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

@@ -1,5 +1,5 @@
 import os from 'os';
-import { getConfiguration } from '../../../utils';
+import { getConfigurationSafe } from '../../../utils';
 import { CommandName } from '../../../utils/get-configuration';
 
 import { setNodeOptions } from '../set-node-options';
@@ -9,7 +9,7 @@ jest.mock('os', () => ({
 }));
 
 jest.mock('../../../utils', () => ({
-    getConfiguration: jest.fn(() => ({})),
+    getConfigurationSafe: jest.fn(() => ({})),
 }));
 
 describe(`[startup] utils:${setNodeOptions.name}`, () => {
@@ -76,7 +76,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
 
         beforeEach(() => {
             options = ['--no-warning', '--test'];
-            (getConfiguration as jest.Mock).mockImplementation(() => ({
+            (getConfigurationSafe as jest.Mock).mockImplementation(() => ({
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 NODE_OPTIONS: options,
             }));
@@ -117,7 +117,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
         const options = ['--no-warning', '--test'];
 
         beforeEach(() =>
-            (getConfiguration as jest.Mock).mockReturnValue({
+            (getConfigurationSafe as jest.Mock).mockReturnValue({
                 // eslint-disable-next-line @typescript-eslint/naming-convention
                 [command]: { NODE_OPTIONS: options },
             })

package/src/cli/utils/bundle.ts

@@ -6,18 +6,14 @@ import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 
-import {
-    getFolders,
-    getPackageName,
-    getPackageData,
-    isWebComponent,
-    loadSharedDependencies,
-    readJson,
-    log,
-    readJsonSafe,
-} from '../../utils';
+import { getPackageName, isWebComponent, log } from '../../utils';
 import { Overrides, createWebpackConfig } from '../../webpack';
 
+interface Options {
+    buildStat?: boolean;
+    config?: string;
+}
+
 function getName() {
     const packageName = getPackageName()
         .replace(/\//g, '-')
@@ -30,48 +26,15 @@ function getName() {
 export const webpackDevConfigFileName = 'webpack.dev.config.js';
 export const webpackProdConfigFileName = 'webpack.prod.config.js';
 
-function generateWebComponentMetadata(name: string) {
-    const { destination } = getFolders();
-    const packageData = getPackageData();
-
-    const sharedDependencies = loadSharedDependencies(
-        packageData.dependencies,
-        packageData.sharedDependencies
-    );
-
-    if (!fs.existsSync(`./${destination}`)) {
-        fs.mkdirSync(`./${destination}`, { recursive: true });
-    }
-
-    const entryPointsFull = readJsonSafe(path.join('dist', 'bundle', 'full', 'entrypoints.json'));
-    const entryPointsLight = readJsonSafe(path.join('dist', 'bundle', 'light', 'entrypoints.json'));
-
-    fs.writeFileSync(
-        `./${destination}/metadata.json`,
-        JSON.stringify({
-            name,
-            bundledWith: {
-                '@servicetitan/startup': readJson(
-                    path.join(
-                        path.dirname(require.resolve('@servicetitan/startup')),
-                        '../package.json'
-                    )
-                ).version,
-            },
-            sharedDependencies,
-            dependencies: packageData.dependencies,
-            entrypoints: {
-                ...(entryPointsFull ? { full: entryPointsFull } : {}),
-                ...(entryPointsLight ? { light: entryPointsLight } : {}),
-            },
-        }),
-        'utf8'
-    );
-}
-
-export async function bundle(buildStat: boolean) {
+export async function bundle(options: Options = {}) {
     log.info('Bundling the package...');
 
+    const name = getName();
+    const mode = 'production';
+    const fallback = `./${webpackProdConfigFileName}`;
+    const config = readWebpackConfig({ ...options, fallback });
+    const { buildStat } = options;
+
     const run = async (config: Configuration) => {
         const compiler = webpack(config);
 
@@ -92,54 +55,28 @@ export async function bundle(buildStat: boolean) {
         process.stdout.write(stats.toString(config.stats) + '\n');
     };
 
-    const name = getName();
-    const configRelativePath = `./${webpackProdConfigFileName}`;
-
     if (isWebComponent()) {
-        let webpackConfig: Overrides = {
-            configuration: { mode: 'production' },
+        const webpackConfig: Overrides = {
+            configuration: { ...config?.configuration, mode },
+            plugins: config?.plugins,
         };
 
-        if (fs.existsSync(configRelativePath)) {
-            const { configuration, plugins } = require(path.resolve(configRelativePath));
-
-            webpackConfig = {
-                configuration: {
-                    ...configuration,
-                    ...webpackConfig.configuration,
-                },
-                plugins: {
-                    ...plugins,
-                    ...webpackConfig.plugins,
-                },
-            };
-        }
-
         return Promise.all([
             run(createWebpackConfig(webpackConfig, { embed: true, name, buildStat })),
             run(createWebpackConfig(webpackConfig, { name, buildStat })),
-        ]).then(result => {
-            generateWebComponentMetadata(name);
-
-            return result;
-        });
+        ]);
     }
 
-    return run(
-        fs.existsSync(configRelativePath)
-            ? require(path.resolve(configRelativePath))
-            : createWebpackConfig(
-                  {
-                      configuration: { mode: 'production' },
-                  },
-                  { buildStat, name }
-              )
-    );
+    return run(config ?? createWebpackConfig({ configuration: { mode } }, { buildStat, name }));
 }
 
-export async function bundleWatch() {
+export async function bundleWatch(options: Options = {}) {
     log.info('Bundling the package...');
 
+    const name = getName();
+    const mode = 'development';
+    const config = readWebpackConfig({ ...options, fallback: `./${webpackDevConfigFileName}` });
+
     const runServe = async ({ devServer = {}, ...config }: Configuration) => {
         const compiler = webpack(config);
         const host = devServer.host ?? 'localhost';
@@ -174,45 +111,27 @@ export async function bundleWatch() {
         });
     };
 
-    const name = getName();
-    const configRelativePath = `./${webpackDevConfigFileName}`;
-
     if (isWebComponent()) {
-        generateWebComponentMetadata(name);
-
-        let webpackConfig: Overrides = {
-            configuration: { mode: 'development' },
+        const webpackConfig: Overrides = {
+            configuration: { ...config?.configuration, mode },
+            plugins: config?.plugins,
         };
 
-        if (fs.existsSync(configRelativePath)) {
-            const { configuration, plugins } = require(path.resolve(configRelativePath));
-
-            webpackConfig = {
-                configuration: {
-                    ...configuration,
-                    ...webpackConfig.configuration,
-                },
-                plugins: {
-                    ...plugins,
-                    ...webpackConfig.plugins,
-                },
-            };
-        }
-
         return Promise.all([
             run(createWebpackConfig(webpackConfig, { embed: true, name })),
             runServe(createWebpackConfig(webpackConfig, { name })),
         ]);
     }
 
-    return runServe(
-        fs.existsSync(configRelativePath)
-            ? require(path.resolve(configRelativePath))
-            : createWebpackConfig(
-                  {
-                      configuration: { mode: 'development' },
-                  },
-                  { name }
-              )
-    );
+    return runServe(config ?? createWebpackConfig({ configuration: { mode } }, { name }));
+}
+
+function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {
+    return readConfig(config) ?? readConfig(fallback);
+}
+
+function readConfig(relativePath?: string): Record<string, any> | undefined {
+    if (relativePath && fs.existsSync(relativePath)) {
+        return require(path.resolve(relativePath));
+    }
 }

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

@@ -1,5 +1,5 @@
 import os from 'os';
-import { CommandName, NodeConfiguration, getConfiguration } from '../../utils';
+import { CommandName, NodeConfiguration, getConfigurationSafe } from '../../utils';
 
 const MAX_OLD_SPACE_SIZE_OPTION = 'max_old_space_size';
 const DEFAULT_MAX_OLD_SPACE_SIZE_MB = 8192;
@@ -11,7 +11,7 @@ const MIN_REMAINING_MEMORY_MB = 512;
  * @returns whether process's NODE_OPTIONS were changed
  */
 export function setNodeOptions(command: CommandName) {
-    const cliConfig = getConfiguration();
+    const cliConfig = getConfigurationSafe();
     const cmdConfig: NodeConfiguration = cliConfig[command];
 
     const cmdNodeOptions = cmdConfig?.NODE_OPTIONS?.join(' ') ?? '';