@servicetitan/startup 27.4.0 → 28.0.0

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,132 @@
+import { isWebComponent, log, logErrors, readJson } from '../../utils';
+import { npmGetPackageVersionDates, npmUnpublish } from '../utils/cli-npm';
+import { getBranchConfigs } from './get-branch-configs';
+import { Command } from './types';
+
+export interface ArgsPackageClean {
+    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;
+        }
+
+        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;
+    }
+}

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 { getDefaultBuildVersion } from '../utils/publish';
+import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
+import { getBranchConfigs } from './get-branch-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 = 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,
+        };
+    }
+
+    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,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' },
-    };
-};