@servicetitan/startup 27.4.0 → 28.1.0

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

@@ -0,0 +1,189 @@
+import path from 'path';
+import fs from 'fs';
+import { getFolders, isWebComponent, log, logErrors, readJson } from '../../utils';
+import { gitGetBranch, gitGetCommitHash } from '../utils/cli-git';
+import {
+    npmGetPackageVersions,
+    npmPackageSet,
+    npmPublish,
+    npmPublishDry,
+    npmTagVersion,
+} from '../utils/cli-npm';
+import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { getDefaultBuildVersion } from '../utils/publish';
+import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
+import { Command } from './types';
+
+export interface ArgsPackagePublish {
+    branch?: string;
+    build?: string;
+    dry?: boolean;
+    force?: boolean;
+    registry?: string;
+    tag?: string | false;
+}
+
+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;
+        }
+
+        this.validateMetadata();
+
+        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 = getBranchesConfigs()[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?.publishTag ?? '';
+        }
+
+        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,
+        };
+    }
+
+    private validateMetadata() {
+        const { destination: outDir } = getFolders();
+
+        const metadataJson = path.join(outDir, 'metadata.json');
+        if (!fs.existsSync(metadataJson)) {
+            throw new Error(`${metadataJson} is not present`);
+        }
+
+        const metadata = readJson<Metadata>(metadataJson);
+        this.validateEntryPoints(outDir, metadata);
+    }
+
+    private validateEntryPoints(outDir: string, { entrypoints = {} }: Metadata) {
+        const keys: (keyof EntryPoints)[] = ['full', 'light'];
+        keys.forEach(name =>
+            this.validateEntryPoint({ entryPoint: entrypoints[name], name, outDir })
+        );
+    }
+
+    private validateEntryPoint({
+        entryPoint = {},
+        name,
+        outDir,
+    }: {
+        entryPoint?: EntryPoint;
+        name: keyof EntryPoints;
+        outDir: string;
+    }) {
+        const keys: (keyof EntryPoint)[] = ['css', 'js'];
+        keys.forEach(key => {
+            if (!entryPoint[key]) {
+                throw new Error(`${name}.${key} not found in metadata.json`);
+            }
+            entryPoint[key].forEach(filename => {
+                if (!fs.existsSync(path.join(outDir, 'bundle', name, filename))) {
+                    throw new Error(`referenced bundle ${filename} was not found`);
+                }
+            });
+        });
+    }
+}

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

@@ -1,45 +1,18 @@
-import path from 'path';
-
 import {
     getPackages,
+    isWebComponent,
     logErrors,
     PackageType,
-    readJson,
     splitPackagesByType,
-    isWebComponent,
-    log,
 } 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 {
+interface Args extends Omit<ArgsPackagePublish, 'branch'>, ArgsPackageClean {
     clean?: boolean;
+    concurrency?: number;
     scope?: string | string[];
 }
 
@@ -53,11 +26,7 @@ export class MFEPublish implements Command {
     @logErrors
     async execute() {
         let packages = splitPackagesByType(getPackages())[PackageType.Webpack] ?? [];
-        packages = packages.filter(p => {
-            const packageJson = readJson(path.join(p.location, 'package.json'));
-
-            return packageJson?.cli?.['web-component'] === true;
-        });
+        packages = packages.filter(p => isWebComponent(p.location));
 
         if (this.args.scope) {
             packages = packages.filter(p =>
@@ -71,21 +40,21 @@ export class MFEPublish implements Command {
             throw new Error('no packages found for publication');
         }
 
+        const isClean = !!this.args.clean;
         await lernaExec({
-            'cmd': `startup mfe-package-${this.args.clean ? 'clean' : 'publish'}`,
+            'cmd': `startup mfe-package-${isClean ? 'clean' : 'publish'}`,
             'concurrency': this.args.concurrency ?? 1,
             'scope': packages.map(({ name }) => name),
             'stream': true,
-            '--': this.getPublishOptions(),
+            '--': isClean ? this.getCleanOptions() : this.getPublishOptions(),
         });
     }
 
     getPublishOptions() {
-        const { build, branch, count, dry, force, registry, tag } = this.args;
+        const { build, branch, dry, force, registry, tag } = this.args as ArgsPackagePublish;
         return [
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
-            ...[count && `--count ${count}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[registry && `--registry ${registry}`],
@@ -93,262 +62,13 @@ export class MFEPublish implements Command {
             ...[tag === false && `--no-tag`],
         ].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;
+    getCleanOptions() {
+        const { branch, count } = this.args as ArgsPackageClean;
+        return [
+            ...[branch && typeof branch === 'string' && `--branch ${branch}`],
+            ...[branch && branch === true && '--branch'],
+            ...[count && `--count ${count}`],
+        ].filter(item => !!item) as string[];
     }
 }
-
-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__/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();