@servicetitan/startup 27.4.0 → 28.1.0

package/src/cli/commands/__tests__/init.test.ts

@@ -1,67 +1,118 @@
-import cpx from 'cpx2';
-import path from 'path';
 import { fs, vol } from 'memfs';
+import { mkdirSync, rmSync } from 'fs';
+import path from 'path';
 
 import { Init } from '../init';
+import { runCommand, runCommandOutput } from '../../utils/cli-os';
 
 jest.mock('fs', () => fs);
-
-jest.mock('cpx2', () => ({
-    copy: jest.fn().mockImplementation((...args: any[]) => {
-        const callback = args[args.length - 1];
-        callback(null);
-    }),
-}));
-
+jest.mock('../../utils//cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
 jest.mock('../../../utils', () => ({
     log: { info: jest.fn() }, // suppress log output
 }));
 
+const webUrl = 'https://github.com/servicetitan/frontend-example.git';
+const sshUrl = 'git@github.com:servicetitan/frontend-example.git';
+
 describe(`[startup] ${Init.name}`, () => {
     let args: ConstructorParameters<typeof Init>[0];
 
     beforeEach(() => {
         args = {};
         vol.reset();
+        jest.clearAllMocks();
+        jest.mocked(runCommand).mockImplementation(jest.fn());
+        jest.mocked(runCommandOutput).mockImplementation(jest.fn());
+        jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
+        jest.spyOn(fs, 'rmSync').mockImplementation(jest.fn());
     });
 
     const subject = async () => new Init(args).execute();
 
-    function itCopies(...names: string[]) {
-        test.each(names)(`copies %s to current directory`, async (name: string) => {
+    test(`clones ${webUrl} to current directory`, async () => {
+        const cwd = path.resolve('.');
+        await subject();
+
+        expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${cwd}`, {
+            quiet: true,
+        });
+        expect(rmSync).toHaveBeenCalledWith(path.join(cwd, '.git'), {
+            recursive: true,
+            force: true,
+        });
+        expect(rmSync).toHaveBeenCalledWith(path.join(cwd, '.github', 'CODEOWNERS'));
+        expect(rmSync).toHaveBeenCalledWith(path.join(cwd, 'package-lock.json'));
+    });
+
+    describe(`when cloning ${webUrl} fails`, () => {
+        beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
+
+        test(`clones ${sshUrl} to current directory`, async () => {
             await subject();
 
-            expect(cpx.copy).toHaveBeenCalledWith(
-                expect.stringContaining(path.join(name, '**', '{.*,*,.*/*}')),
-                process.cwd(),
+            expect(runCommand).toHaveBeenCalledWith(
+                `git clone -q ${sshUrl} ${path.resolve('.')}`,
                 expect.anything()
             );
         });
-    }
 
-    itCopies('template', 'template-react18');
+        describe(`when cloning ${sshUrl} also fails`, () => {
+            beforeEach(() => {
+                jest.mocked(runCommand).mockRejectedValue('Nope!');
+            });
 
-    describe('when instructed to create React 17 template', () => {
-        beforeEach(() => (args.react17 = true));
+            test(`checks if ${webUrl} is reachable`, async () => {
+                await subject();
 
-        itCopies('template');
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+                    quiet: true,
+                });
+            });
+
+            describe(`when ${webUrl} is not reachable`, () => {
+                beforeEach(() => {
+                    jest.mocked(runCommandOutput).mockImplementationOnce(() => {
+                        throw new Error('Oops!');
+                    });
+                });
+
+                test(`checks if ${sshUrl} is reachable`, async () => {
+                    await subject();
+
+                    expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                        quiet: true,
+                    });
+                });
+
+                describe(`when ${sshUrl} is also unreachable`, () => {
+                    beforeEach(() =>
+                        jest.mocked(runCommandOutput).mockImplementation(() => {
+                            throw new Error('Oops');
+                        })
+                    );
+
+                    test('raises error', async () => {
+                        await expect(subject()).rejects.toThrow(
+                            /could not read servicetitan\/frontend-example repository/
+                        );
+                    });
+                });
+            });
+        });
     });
 
     describe('with an output location', () => {
         beforeEach(() => (args.output = 'foo/bar'));
 
-        test('copies template to output location', async () => {
-            const mkdirSpy = jest.spyOn(fs, 'mkdirSync');
+        test(`clones ${webUrl} to output location`, async () => {
             const destination = path.resolve(args.output!);
 
             await subject();
 
-            expect(mkdirSpy).toHaveBeenCalledWith(destination, { recursive: true });
-            expect(cpx.copy).toHaveBeenCalledWith(
-                expect.any(String),
-                destination,
-                expect.anything()
-            );
+            expect(mkdirSync).toHaveBeenCalledWith(destination, { recursive: true });
+            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                quiet: true,
+            });
         });
 
         describe('when output location is a file', () => {
@@ -71,5 +122,34 @@ describe(`[startup] ${Init.name}`, () => {
                 await expect(subject()).rejects.toThrow(/is not a directory/);
             });
         });
+
+        describe('when output location is not empty', () => {
+            beforeEach(() => vol.fromNestedJSON({ [args.output!]: { baz: '' } }));
+
+            test('raises error', async () => {
+                await expect(subject()).rejects.toThrow(/is not an empty directory/);
+            });
+        });
+    });
+
+    describe('when running in CI environment with GITHUB_TOKEN', () => {
+        const originalEnv = process.env;
+        const token = 'foo-bar';
+
+        beforeEach(() => {
+            process.env.CI = 'true';
+            process.env.GITHUB_TOKEN = token;
+        });
+        afterEach(() => (process.env = originalEnv));
+
+        test(`adds token to ${webUrl}`, async () => {
+            await subject();
+
+            const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
+            expect(runCommand).toHaveBeenCalledWith(
+                `git clone -q ${urlWithToken} ${path.resolve('.')}`,
+                expect.anything()
+            );
+        });
     });
 });

package/src/cli/commands/__tests__/mfe-package-clean.test.ts

@@ -1,8 +1,9 @@
 import { fs, vol } from 'memfs';
 import { isWebComponent, log } from '../../../utils';
+import { gitGetBranch } from '../../utils/cli-git';
 import { npmGetPackageVersionDates, npmUnpublish } from '../../utils/cli-npm';
 
-import { MFEPackageClean } from '../mfe-publish';
+import { MFEPackageClean } from '../mfe-package-clean';
 
 jest.mock('fs', () => fs);
 jest.mock('../../../utils', () => ({
@@ -14,6 +15,9 @@ jest.mock('../../utils/cli-npm', () => ({
     npmGetPackageVersionDates: jest.fn(),
     npmUnpublish: jest.fn(),
 }));
+jest.mock('../../utils/cli-git', () => ({
+    gitGetBranch: jest.fn(),
+}));
 
 const DEFAULT_VERSIONS_TO_KEEP = 5;
 
@@ -23,18 +27,23 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
     let args: ConstructorParameters<typeof MFEPackageClean>[0];
     let versions: Record<string, Date>;
 
-    beforeEach(() => {
-        args = {};
-        versions = Object.fromEntries(
-            Array.from({ length: 10 }).map((_, index) => [
-                `0.0.0-master.${(0xff000000 + index).toString(16)}`,
+    function getBranchVersions(branchName: string, length: number) {
+        return Object.fromEntries(
+            Array.from({ length }).map((_, index) => [
+                `0.0.0-${branchName}.${(0xff000000 + index).toString(16)}`,
                 dayAgo(index + 1), // tests assume versions are in reverse chronological order
             ])
         );
+    }
+
+    beforeEach(() => {
+        args = {};
+        versions = getBranchVersions('master', 10);
 
         jest.resetAllMocks();
         jest.mocked(isWebComponent).mockReturnValue(true);
         jest.mocked(npmGetPackageVersionDates).mockImplementation(() => Object.entries(versions));
+        jest.mocked(gitGetBranch).mockImplementation(() => 'current');
         vol.fromJSON({ 'package.json': JSON.stringify({ name: packageName }) });
     });
 
@@ -74,6 +83,36 @@ describe(`[startup] ${MFEPackageClean.name}`, () => {
         itLogsAndUnpublishedOldestPackages({ branch });
     });
 
+    describe.each(['qa', true])('when selected branch is %s', (branch: string | true) => {
+        let branchedVersions: typeof versions = {};
+        const branchName = branch === true ? 'current' : branch;
+
+        beforeEach(() => {
+            args.branch = branch;
+
+            branchedVersions = getBranchVersions(branchName, 7);
+
+            versions = {
+                ...versions,
+                ...branchedVersions,
+            };
+        });
+
+        test(`logs and unpublishes oldest packages for ${branchName} branch`, async () => {
+            const oldest = Object.entries(branchedVersions).slice(DEFAULT_VERSIONS_TO_KEEP);
+
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                'found versions for unpublish:',
+                JSON.stringify({ [branchName]: oldest }, null, 4)
+            );
+            oldest.forEach(([version]) => {
+                expect(npmUnpublish).toHaveBeenCalledWith(registry, packageName, version);
+            });
+        });
+    });
+
     describe('with master versions generated by nerdbank versioning', () => {
         beforeEach(() => {
             versions = transform(versions, (v: string, index: number) =>

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

@@ -1,5 +1,6 @@
 import { fs, vol } from 'memfs';
-import { isWebComponent, log } from '../../../utils';
+import path from 'path';
+import { isWebComponent, log, readJson } from '../../../utils';
 import { gitGetBranch, gitGetCommitHash } from '../../utils/cli-git';
 import {
     npmGetPackageVersions,
@@ -8,7 +9,7 @@ import {
     npmPublishDry,
     npmTagVersion,
 } from '../../utils/cli-npm';
-import { MFEPackagePublish } from '../mfe-publish';
+import { MFEPackagePublish } from '../mfe-package-publish';
 
 jest.mock('fs', () => fs);
 jest.mock('../../../utils', () => ({
@@ -44,7 +45,30 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         jest.mocked(gitGetBranch).mockReturnValue(branch);
         jest.mocked(gitGetCommitHash).mockReturnValue(commitHash);
         jest.mocked(npmGetPackageVersions).mockReturnValue([]);
-        vol.fromJSON({ 'package.json': JSON.stringify({ name: packageName, files: [] }) });
+        vol.fromNestedJSON({
+            'package.json': JSON.stringify({ name: packageName, files: [] }),
+            'tsconfig.json': JSON.stringify({
+                compilerOptions: { outDir: 'dist', rootDir: 'src' },
+            }),
+            'dist': {
+                'metadata.json': JSON.stringify({
+                    entrypoints: {
+                        full: { css: ['main.bundle.css'], js: ['main.bundle.js'] },
+                        light: { css: ['main.bundle.css'], js: ['main.bundle.js'] },
+                    },
+                }),
+                'bundle': {
+                    full: {
+                        'main.bundle.css': '',
+                        'main.bundle.js': '',
+                    },
+                    light: {
+                        'main.bundle.css': '',
+                        'main.bundle.js': '',
+                    },
+                },
+            },
+        });
     });
 
     afterEach(() => vol.reset());
@@ -239,17 +263,63 @@ describe(`[startup] ${MFEPackagePublish.name}`, () => {
         });
     });
 
-    describe('when package is not web component', () => {
-        beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(false));
-
+    function itThrowsError(message: RegExp) {
         test('throws error', async () => {
             jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
             expect.assertions(1);
             try {
                 await subject();
             } catch (error: any) {
-                expect(error.message).toMatch(/only web-components can be published/);
+                expect(error.message).toMatch(message);
             }
         });
+    }
+
+    describe('when package is not web component', () => {
+        beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(false));
+
+        itThrowsError(/only web-components can be published/);
+    });
+
+    describe('when metadata.json is missing', () => {
+        beforeEach(() => fs.unlinkSync('dist/metadata.json'));
+
+        itThrowsError(/metadata.json is not present/);
+    });
+
+    describe(`when metadata.json contains no entrypoints`, () => {
+        beforeEach(() => {
+            const metadataJson = path.join('dist', 'metadata.json');
+            const metadata = readJson(metadataJson);
+            delete metadata.entrypoints;
+            fs.writeFileSync(metadataJson, JSON.stringify(metadata));
+        });
+
+        itThrowsError(/not found in metadata.json/);
+    });
+
+    ['full', 'light'].forEach(name => {
+        describe.each(['css', 'js'])(`when ${name}.%s entry point is missing`, key => {
+            beforeEach(() => {
+                const metadataJson = path.join('dist', 'metadata.json');
+                const metadata = readJson(metadataJson);
+                delete metadata.entrypoints[name][key];
+                fs.writeFileSync(metadataJson, JSON.stringify(metadata));
+            });
+
+            itThrowsError(new RegExp(`${name}.${key} not found in metadata.json`));
+        });
+
+        describe(`when ${name} JS bundle is missing`, () => {
+            beforeEach(() => fs.unlinkSync(`dist/bundle/${name}/main.bundle.js`));
+
+            itThrowsError(/referenced bundle main.bundle.js was not found/);
+        });
+
+        describe(`when ${name} CSS bundle is missing`, () => {
+            beforeEach(() => fs.unlinkSync(`dist/bundle/${name}/main.bundle.css`));
+
+            itThrowsError(/referenced bundle main.bundle.css was not found/);
+        });
     });
 });

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

@@ -94,6 +94,25 @@ describe(`[startup] ${MFEPublish.name}`, () => {
                     expect.objectContaining({ cmd: 'startup mfe-package-clean' })
                 );
             });
+
+            type ArgumentName = keyof typeof args;
+            const testArgs: { name: ArgumentName; value: any; expected?: string }[] = [
+                { name: 'count', value: 10 },
+                { name: 'branch', value: 'foo-123' },
+                { name: 'branch', value: true, expected: '--branch' },
+            ];
+
+            describe.each(testArgs)('with "{$name: $value}"', ({ name, value, expected }) => {
+                beforeEach(() => (args[name] = value));
+
+                test(`runs clean with "${expected ?? `--${name} ${value}`}"`, async () => {
+                    await subject();
+
+                    expect(lernaExec).toHaveBeenCalledWith(
+                        expect.objectContaining({ '--': [expected ?? `--${name} ${value}`] })
+                    );
+                });
+            });
         });
 
         type ArgumentName = keyof typeof args;
@@ -105,7 +124,6 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             { name: 'dry', value: true, expected: '--dry' },
             { name: 'force', value: true, expected: '--force' },
             { name: 'registry', value: 'https://foo' },
-            { name: 'count', value: 42 },
         ];
 
         describe.each(testArgs)('with "{$name: $value}"', ({ name, value, expected }) => {

package/src/cli/commands/__tests__/tests.test.ts

@@ -30,10 +30,14 @@ describe(`[startup] ${Tests.name}`, () => {
     });
 
     describe('when the command fails', () => {
+        const exitCode = process.exitCode;
+
         beforeEach(() => {
             jest.mocked(runCLI).mockResolvedValue({ results: { success: false } } as any);
         });
 
+        afterAll(() => (process.exitCode = exitCode));
+
         test('sets process execCode to 1', async () => {
             await subject();
 

package/src/cli/commands/get-command.ts

@@ -7,7 +7,9 @@ import { Init } from './init';
 import { Install } from './install';
 import { KendoUILicense } from './kendo-ui-license';
 import { Lint } from './lint';
-import { MFEPackageClean, MFEPackagePublish, MFEPublish } from './mfe-publish';
+import { MFEPackageClean } from './mfe-package-clean';
+import { MFEPackagePublish } from './mfe-package-publish';
+import { MFEPublish } from './mfe-publish';
 import { PreparePackage } from './prepare-package';
 import { Start } from './start';
 import { StylesCheck } from './styles-check';

package/src/cli/commands/init.ts

@@ -1,21 +1,22 @@
 import fs from 'fs';
-import cpx from 'cpx2';
-import util from 'util';
 import path from 'path';
 
 import { log, logErrors } from '../../utils';
+import { runCommand, runCommandOutput } from '../utils/cli-os';
 import { Command } from './';
 
 interface Args {
-    react17?: boolean;
     output?: string;
 }
 
+const webUrl = 'https://github.com/servicetitan/frontend-example.git';
+const sshUrl = 'git@github.com:servicetitan/frontend-example.git';
+
 export class Init implements Command {
     constructor(private args: Args) {}
 
     description() {
-        return 'generate empty project';
+        return 'create example project';
     }
 
     @logErrors
@@ -25,18 +26,47 @@ export class Init implements Command {
             fs.mkdirSync(destination, { recursive: true });
         } else if (!fs.lstatSync(destination).isDirectory()) {
             throw new Error(`${destination} is not a directory`);
+        } else if (fs.readdirSync(destination).length !== 0) {
+            throw new Error(`${destination} is not an empty directory`);
         }
 
-        await copyFiles('template', destination);
+        const gitUrls = [webUrl, sshUrl];
+        if (!!process.env.CI && !!process.env.GITHUB_TOKEN) {
+            gitUrls.unshift(
+                webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)
+            );
+        }
 
-        if (!this.args.react17) {
-            await copyFiles('template-react18', destination);
+        for await (const url of gitUrls) {
+            if (await cloneRepo(url, destination)) {
+                log.info(`copied example project to ${destination}`);
+                return;
+            }
         }
 
-        log.info(`copied${this.args.react17 ? ' React 17' : ''} template to ${destination}`);
+        if (!gitUrls.some(isReachable)) {
+            throw new Error('could not read servicetitan/frontend-example repository');
+        }
     }
 }
 
-async function copyFiles(from: string, to: string) {
-    await util.promisify(cpx.copy)(path.resolve(__dirname, `../../../${from}/**/{.*,*,.*/*}`), to);
+async function cloneRepo(url: string, destination: string) {
+    try {
+        await runCommand(`git clone -q ${url} ${destination}`, { quiet: true });
+    } catch (e) {
+        return false;
+    }
+    fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
+    fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
+    fs.rmSync(path.join(destination, 'package-lock.json'));
+    return true;
+}
+
+function isReachable(url: string) {
+    try {
+        runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
+    } catch (e) {
+        return false;
+    }
+    return true;
 }

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

@@ -0,0 +1,143 @@
+import { isWebComponent, log, logErrors, readJson } from '../../utils';
+import { gitGetBranch } from '../utils/cli-git';
+import { npmGetPackageVersionDates, npmUnpublish } from '../utils/cli-npm';
+import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { Command } from './types';
+
+export interface ArgsPackageClean {
+    branch?: string | true;
+    count?: number;
+}
+
+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;
+        }
+
+        let branches: string[];
+
+        if (this.args.branch === true) {
+            branches = [gitGetBranch()];
+        } else if (typeof this.args.branch === 'string') {
+            branches = [this.args.branch];
+        } else {
+            branches = Object.keys(getBranchesConfigs());
+        }
+
+        const registry = 'https://verdaccio.servicetitan.com';
+
+        return { count, registry, branches };
+    }
+
+    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;
+    }
+}