@servicetitan/startup 27.2.1 → 27.4.0-canary.0

package/src/cli/commands/mfe-publish.ts

@@ -1,45 +1,14 @@
 import path from 'path';
 
-import {
-    getPackages,
-    logErrors,
-    PackageType,
-    readJson,
-    splitPackagesByType,
-    isWebComponent,
-    log,
-} from '../../utils';
+import { getPackages, logErrors, PackageType, readJson, splitPackagesByType } from '../../utils';
+import { ArgsPackageClean } from './mfe-package-clean';
+import { ArgsPackagePublish } from './mfe-package-publish';
+import { Command } from './types';
 import { lernaExec } from '../utils';
-import { gitGetBranch, gitGetCommitHash } from '../utils/cli-git';
-import {
-    npmGetPackageVersionDates,
-    npmGetPackageVersions,
-    npmPackageSet,
-    npmPublish,
-    npmPublishDry,
-    npmTagVersion,
-    npmUnpublish,
-} from '../utils/cli-npm';
-import { getDefaultBuildVersion } from '../utils/publish';
-import { Command } from '.';
-
-interface ArgsPackagePublish {
-    branch?: string;
-    build?: string;
-    concurrency?: number;
-    dry?: boolean;
-    force?: boolean;
-    noTag?: string;
-    registry?: string;
-    tag?: string | false;
-}
-
-interface ArgsPackageClean {
-    count?: number;
-}
 
 interface Args extends ArgsPackagePublish, ArgsPackageClean {
     clean?: boolean;
+    concurrency?: number;
     scope?: string | string[];
 }
 
@@ -94,261 +63,3 @@ export class MFEPublish implements Command {
         ].filter(item => !!item) as string[];
     }
 }
-
-export class MFEPackagePublish implements Command {
-    constructor(private args: ArgsPackagePublish) {}
-
-    description() {
-        return undefined;
-    }
-
-    @logErrors
-    async execute() {
-        if (!isWebComponent()) {
-            throw new Error('only web-components can be published');
-        }
-
-        const packageJson = readJson('package.json');
-
-        if (packageJson.private) {
-            log.info('package is private, skipping publish');
-            return;
-        }
-
-        const data = this.getPublishData();
-        const packageName = packageJson.name;
-
-        if (!data.version) {
-            log.info('no build version found, skipping publish');
-            return;
-        }
-
-        if (!data.isBranchConfigured && !data.force) {
-            log.info(
-                'branch is not configured for publishing, use --force flag to publish if needed'
-            );
-            return;
-        }
-
-        const versions = npmGetPackageVersions(data.registry, packageName);
-        const dryRunPrefix = data.dry ? '(dry-run) ' : '';
-
-        if (versions.includes(data.version)) {
-            log.info(
-                `${dryRunPrefix}${packageName} version ${data.version} is already published, skipping publish`
-            );
-
-            if (data.tag) {
-                log.info(
-                    `${dryRunPrefix}adding tag "${data.tag}" to ${packageName} version ${data.version}`
-                );
-                if (!data.dry) {
-                    await npmTagVersion({
-                        packageName,
-                        packageVersion: data.version,
-                        registry: data.registry,
-                        tag: data.tag,
-                    });
-                }
-            }
-            return;
-        }
-
-        await npmPackageSet('version', data.version);
-        await npmPackageSet('publishConfig.registry', data.registry);
-
-        if (!packageJson.files) {
-            await npmPackageSet('files[0]', 'dist');
-            await npmPackageSet('files[1]', 'package.json');
-        }
-
-        if (data.dry) {
-            await npmPublishDry();
-        } else {
-            await npmPublish(data.tag);
-        }
-
-        log.info(`${dryRunPrefix}published ${packageName} version ${data.version}`);
-    }
-
-    private getPublishData(): {
-        version: string;
-        buildVersion: string;
-        tag?: string;
-        registry: string;
-        dry: boolean;
-        force: boolean;
-        isBranchConfigured: boolean;
-    } {
-        const cli = this.args;
-        const branch = cli.branch ?? gitGetBranch();
-        const branchConfig = getBranchConfigs()[branch];
-        let buildVersion = cli.build;
-
-        if (!buildVersion) {
-            buildVersion = getDefaultBuildVersion(branch, gitGetCommitHash());
-        }
-
-        if (!buildVersion) {
-            throw new Error('build version is not set');
-        }
-
-        let tag: string;
-
-        if (cli.tag === false) {
-            tag = '';
-        } else if (cli.tag) {
-            tag = cli.tag;
-        } else {
-            tag = branchConfig?.tag ?? '';
-        }
-
-        const registry = cli.registry ?? 'https://verdaccio.servicetitan.com';
-
-        return {
-            tag,
-            version: '0.0.0-' + buildVersion,
-            buildVersion,
-            registry,
-            dry: !!cli.dry,
-            force: !!cli.force,
-            isBranchConfigured: !!branchConfig,
-        };
-    }
-}
-
-export class MFEPackageClean implements Command {
-    constructor(private args: ArgsPackageClean) {}
-
-    description() {
-        return undefined;
-    }
-
-    @logErrors
-    async execute() {
-        if (!isWebComponent()) {
-            throw new Error('only web-components can be cleaned');
-        }
-
-        const data = this.getCleanData();
-        const packageJson = readJson('package.json');
-        const packageName = packageJson.name;
-        const branchedVersions = this.getBranchedVersions(packageName, data.registry);
-
-        log.info(
-            `branched versions (${data.count}):`,
-            JSON.stringify(branchedVersions, undefined, 4)
-        );
-
-        const branchedVersionsToClean: Record<string, [string, Date][]> = {};
-
-        for (const branch of Object.keys(branchedVersions)) {
-            // limit branches for now
-            if (!branchedVersions[branch] || !data.branches.includes(branch)) {
-                continue;
-            }
-
-            branchedVersions[branch].sort(([, adt], [, bdt]) => (adt > bdt ? -1 : 1));
-            branchedVersionsToClean[branch] = branchedVersions[branch].slice(data.count);
-        }
-
-        log.info(
-            'found versions for unpublish:',
-            JSON.stringify(branchedVersionsToClean, undefined, 4)
-        );
-
-        const unVersions = Object.keys(branchedVersionsToClean).reduce(
-            (out, br) => [...out, ...branchedVersionsToClean[br].map(([v]) => v)],
-            []
-        );
-
-        for (const version of unVersions) {
-            try {
-                // eslint-disable-next-line no-await-in-loop
-                await npmUnpublish(data.registry, packageName, version);
-            } catch {
-                log.error(`error while removing ${packageName} version ${version}`);
-            }
-        }
-    }
-
-    private getCleanData(): {
-        count: number;
-        registry: string;
-        branches: string[];
-    } {
-        let count = this.args.count;
-
-        if (!count) {
-            count = 5;
-        }
-
-        const registry = 'https://verdaccio.servicetitan.com';
-
-        return { count, registry, branches: Object.keys(getBranchConfigs()) };
-    }
-
-    private getBranchedVersions(packageName: string, registry: string) {
-        const versions = npmGetPackageVersionDates(registry, packageName);
-        const branchedVersions: Record<string, [string, Date][]> = {};
-        const unknownVersions: string[] = [];
-
-        const addVersion = (branch: string, version: string, dt: Date) => {
-            if (!branchedVersions[branch]) {
-                branchedVersions[branch] = [];
-            }
-
-            branchedVersions[branch].push([version, dt]);
-        };
-
-        for (const [version, dt] of versions) {
-            if (!version.startsWith('0.0.0-')) {
-                continue;
-            }
-
-            const buildVersion = version.replace('0.0.0-', '');
-
-            if (/^(\d+)\.(\d+)\.(\d+)$/.test(buildVersion)) {
-                // master version generated by nerdbank versioning
-                addVersion('master', version, dt);
-                continue;
-            }
-
-            const match1 = buildVersion.match(
-                /^(\d+)\.(\d+)\.(\d+)-([\dA-Za-z\-]+).([\dA-Za-z]+)$/
-            );
-
-            if (match1?.length) {
-                // branch version generated by nerdbank versioning
-                addVersion(match1[4], version, dt);
-                continue;
-            }
-
-            const match2 = buildVersion.match(/^([\dA-Za-z\-]+).([\dA-Za-z]+)$/);
-
-            if (match2?.length) {
-                // branch version generated by mfe-publisher versioning
-                addVersion(match2[1], version, dt);
-                continue;
-            }
-
-            unknownVersions.push(version);
-        }
-
-        if (unknownVersions.length) {
-            log.info('unknown versions:', unknownVersions.join());
-        }
-
-        return branchedVersions;
-    }
-}
-
-const getBranchConfigs = (): Record<string, { tag?: string }> => {
-    // ToDo: add ability to configure it in a package.json
-    return {
-        develop: { tag: 'dev' },
-        dev: { tag: 'dev' },
-        next: { tag: 'next' },
-        master: { tag: 'prod' },
-    };
-};

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__/bundle.test.ts

@@ -2,7 +2,12 @@ import { fs, vol } from 'memfs';
 import path from 'path';
 import webpack from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
-import { getFolders, getPackageData, loadSharedDependencies } from '../../../utils';
+import {
+    getConfiguration,
+    getFolders,
+    getPackageData,
+    loadSharedDependencies,
+} from '../../../utils';
 import { createWebpackConfig } from '../../../webpack';
 import { createPackage } from '../../../__mocks__';
 
@@ -44,12 +49,12 @@ describe('[startup] Cli Utils', () => {
         return expect.stringContaining(name);
     }
 
-    function packageFS() {
-        return { 'package.json': JSON.stringify(pkg) };
+    function packageFS(configuration: ReturnType<typeof getConfiguration> = {} as any) {
+        return { 'package.json': JSON.stringify({ ...pkg, cli: configuration }) };
     }
 
-    function webComponentFS() {
-        return { 'package.json': JSON.stringify({ ...pkg, cli: { 'web-component': true } }) };
+    function webComponentFS(configuration: ReturnType<typeof getConfiguration> = {} as any) {
+        return packageFS({ 'web-component': true, ...configuration });
     }
 
     describe(`${bundle.name}`, () => {
@@ -287,6 +292,19 @@ describe('[startup] Cli Utils', () => {
             );
         });
 
+        describe('when webpack.devServer is set to false in package.json', () => {
+            beforeEach(() => {
+                vol.fromJSON(packageFS({ webpack: { devServer: false } } as any));
+            });
+
+            test('runs webpack and not webpack development server', async () => {
+                await subject();
+
+                expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+                expect(WebpackDevServer).not.toHaveBeenCalled();
+            });
+        });
+
         function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
             test(`uses ${params.name}`, async () => {
                 const { devServer, ...config } = params.config();
@@ -351,7 +369,8 @@ describe('[startup] Cli Utils', () => {
                     ...options,
                     embed: true,
                 });
-                expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+                expect(webpack).toHaveBeenNthCalledWith(1, createWebpackResult);
+                expect(webpack).toHaveBeenNthCalledWith(2, createWebpackResult);
                 expect(compiler.watch).toHaveBeenCalled();
                 expect(WebpackDevServer).toHaveBeenCalledWith(
                     { host: 'localhost', port: 8080 },
@@ -359,6 +378,26 @@ describe('[startup] Cli Utils', () => {
                 );
             });
 
+            describe('when webpack.devServer is set to false in package.json', () => {
+                beforeEach(() => {
+                    vol.fromJSON(webComponentFS({ webpack: { devServer: false } } as any));
+                });
+
+                test('runs webpack and not webpack development server', async () => {
+                    const options = { name: expectPackageName() };
+                    const overrides = { configuration: { mode: 'development' } };
+
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                        ...options,
+                        embed: true,
+                    });
+                    expect(WebpackDevServer).not.toHaveBeenCalled();
+                });
+            });
+
             function itUsesConfig(params: { name: string; config: () => Record<string, any> }) {
                 test(`uses ${params.name}`, async () => {
                     const options = { name: expectPackageName() };

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__/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/bundle.ts

@@ -6,7 +6,7 @@ import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 
-import { getPackageName, isWebComponent, log } from '../../utils';
+import { getPackageName, isDevServerDisabled, isWebComponent, log } from '../../utils';
 import { Overrides, createWebpackConfig } from '../../webpack';
 
 interface Options {
@@ -62,6 +62,7 @@ export async function bundleWatch(options: Options = {}) {
     const mode = 'development';
     const config = readWebpackConfig({ ...options, fallback: `./${webpackDevConfigFileName}` });
     const { codeCoverage, esbuild, experimentalBundlers } = options;
+    const configOverrides = { codeCoverage, esbuild, experimentalBundlers, name };
 
     if (isWebComponent()) {
         const webpackConfig: Overrides = {
@@ -72,31 +73,24 @@ export async function bundleWatch(options: Options = {}) {
         return Promise.all([
             runWatch(
                 createWebpackConfig(webpackConfig, {
-                    codeCoverage,
                     embed: true,
-                    name,
-                    esbuild,
-                    experimentalBundlers,
-                })
-            ),
-            runServe(
-                createWebpackConfig(webpackConfig, {
-                    name,
-                    codeCoverage,
-                    esbuild,
-                    experimentalBundlers,
+                    ...configOverrides,
                 })
             ),
+            isDevServerDisabled()
+                ? runWatch(createWebpackConfig(webpackConfig, configOverrides))
+                : runServe(createWebpackConfig(webpackConfig, configOverrides)),
         ]);
     }
 
-    return runServe(
-        config ??
-            createWebpackConfig(
-                { configuration: { mode } },
-                { name, codeCoverage, esbuild, experimentalBundlers }
-            )
-    );
+    const webpackConfig =
+        config ?? createWebpackConfig({ configuration: { mode } }, configOverrides);
+
+    if (isDevServerDisabled()) {
+        return runWatch(webpackConfig);
+    }
+
+    return runServe(webpackConfig);
 }
 
 function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {