@servicetitan/startup 28.4.0 → 29.0.0

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

@@ -1,12 +1,15 @@
 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 { gitGetBranch } from '../utils/cli-git';
+import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../utils/cli-npm';
 import { Command } from './types';
 
 export interface ArgsPackageClean {
-    branch?: string | true;
+    all?: true;
+    branch?: string;
     count?: number;
+    dry?: boolean;
+    registry?: string;
 }
 
 export class MFEPackageClean implements Command {
@@ -23,37 +26,34 @@ export class MFEPackageClean implements Command {
         }
 
         const data = this.getCleanData();
-        const packageJson = readJson('package.json');
-        const packageName = packageJson.name;
+        const packageName = readJson('package.json').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][]> = {};
+        log.info(`branched versions (${data.count}):`, JSON.stringify(branchedVersions, null, 2));
 
-        for (const branch of Object.keys(branchedVersions)) {
-            // limit branches for now
-            if (!branchedVersions[branch] || !data.branches.includes(branch)) {
+        const branchedVersionsToClean: Record<string, Version[]> = {};
+        for (const [branch, versions] of Object.entries(branchedVersions)) {
+            // Limit branches for now
+            if (!data.branches.includes(branch)) {
+                log.info(`ignoring unrecognized branch "${branch}"`);
                 continue;
             }
 
-            branchedVersions[branch].sort(([, adt], [, bdt]) => (adt > bdt ? -1 : 1));
-            branchedVersionsToClean[branch] = branchedVersions[branch].slice(data.count);
+            branchedVersionsToClean[branch] = this.excludeTagged(versions)
+                .sort(({ date: adt }, { date: bdt }) => (adt > bdt ? -1 : 1))
+                .slice(data.count);
         }
 
-        log.info(
-            'found versions for unpublish:',
-            JSON.stringify(branchedVersionsToClean, undefined, 4)
-        );
-
+        log.info('found versions for unpublish:', JSON.stringify(branchedVersionsToClean, null, 2));
         const unVersions = Object.keys(branchedVersionsToClean).reduce(
-            (out, br) => [...out, ...branchedVersionsToClean[br].map(([v]) => v)],
+            (out, br) => [...out, ...branchedVersionsToClean[br].map(({ name }) => name)],
             []
         );
 
+        if (this.args.dry) {
+            return;
+        }
+
         for (const version of unVersions) {
             try {
                 // eslint-disable-next-line no-await-in-loop
@@ -64,6 +64,16 @@ export class MFEPackageClean implements Command {
         }
     }
 
+    private excludeTagged(versions: Version[]) {
+        return versions.filter(({ name, tag }) => {
+            if (tag) {
+                log.info(`ignoring version ${name} tagged "${tag}"`);
+                return false;
+            }
+            return true;
+        });
+    }
+
     private getCleanData(): {
         count: number;
         registry: string;
@@ -76,66 +86,57 @@ export class MFEPackageClean implements Command {
 
         let branches: string[];
 
-        if (this.args.branch === true) {
-            branches = [gitGetBranch()];
+        if (this.args.all === true) {
+            branches = Object.keys(getBranchesConfigs());
         } else if (typeof this.args.branch === 'string') {
             branches = [this.args.branch];
         } else {
-            branches = Object.keys(getBranchesConfigs());
+            branches = [gitGetBranch()];
         }
 
-        const registry = 'https://verdaccio.servicetitan.com';
+        const registry = this.args.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] = [];
-            }
+        const versions = npmGetPackageVersionsDetails(registry, packageName);
+        const branchedVersions: Record<string, Version[]> = {};
 
-            branchedVersions[branch].push([version, dt]);
-        };
+        function addVersion(branch: string, version: Version) {
+            branchedVersions[branch] ??= [];
+            branchedVersions[branch].push(version);
+        }
 
-        for (const [version, dt] of versions) {
-            if (!version.startsWith('0.0.0-')) {
+        for (const version of versions) {
+            const { name } = version;
+            if (!name.startsWith('0.0.0-')) {
                 continue;
             }
 
-            const buildVersion = version.replace('0.0.0-', '');
+            const buildVersion = name.replace('0.0.0-', '');
 
+            // master version generated by nerdbank versioning
             if (/^(\d+)\.(\d+)\.(\d+)$/.test(buildVersion)) {
-                // master version generated by nerdbank versioning
-                addVersion('master', version, dt);
+                addVersion('master', version);
                 continue;
             }
 
+            // branch version generated by nerdbank versioning
             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);
+                addVersion(match1[4], version);
                 continue;
             }
 
+            // branch version generated by mfe-publisher versioning
             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);
+                addVersion(match2[1], version);
                 continue;
             }
 
-            unknownVersions.push(version);
-        }
-
-        if (unknownVersions.length) {
-            log.info('unknown versions:', unknownVersions.join());
+            log.info(`skipping unrecognized version: ${name}`);
         }
 
         return branchedVersions;

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

@@ -2,13 +2,7 @@ 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 { npmGetPackageVersions, npmPackageSet, npmPublish, npmTagVersion } from '../utils/cli-npm';
 import { getBranchesConfigs } from '../../utils/get-branch-configs';
 import { getDefaultBuildVersion } from '../utils/publish';
 import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
@@ -20,7 +14,7 @@ export interface ArgsPackagePublish {
     dry?: boolean;
     force?: boolean;
     registry?: string;
-    tag?: string | false;
+    tag?: string;
 }
 
 export class MFEPackagePublish implements Command {
@@ -92,11 +86,7 @@ export class MFEPackagePublish implements Command {
             await npmPackageSet('files[1]', 'package.json');
         }
 
-        if (data.dry) {
-            await npmPublishDry();
-        } else {
-            await npmPublish(data.tag);
-        }
+        await npmPublish({ dry: data.dry, tag: data.tag || data.fallbackTag });
 
         log.info(`${dryRunPrefix}published ${packageName} version ${data.version}`);
     }
@@ -104,11 +94,12 @@ export class MFEPackagePublish implements Command {
     private getPublishData(): {
         version: string;
         buildVersion: string;
-        tag?: string;
+        tag: string;
         registry: string;
         dry: boolean;
         force: boolean;
         isBranchConfigured: boolean;
+        fallbackTag: string;
     } {
         const cli = this.args;
         const branch = cli.branch ?? gitGetBranch();
@@ -119,15 +110,9 @@ export class MFEPackagePublish implements Command {
             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) {
+        if (cli.tag) {
             tag = cli.tag;
         } else {
             tag = branchConfig?.publishTag ?? '';
@@ -143,6 +128,7 @@ export class MFEPackagePublish implements Command {
             dry: !!cli.dry,
             force: !!cli.force,
             isBranchConfigured: !!branchConfig,
+            fallbackTag: 'latest',
         };
     }
 

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

@@ -58,17 +58,18 @@ export class MFEPublish implements Command {
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[registry && `--registry ${registry}`],
-            ...[tag && `--tag ${tag}`],
-            ...[tag === false && `--no-tag`],
+            ...[typeof tag === 'string' && `--tag ${tag}`],
         ].filter(item => !!item) as string[];
     }
 
     getCleanOptions() {
-        const { branch, count } = this.args as ArgsPackageClean;
+        const { all, branch, count, dry, registry } = this.args as ArgsPackageClean;
         return [
-            ...[branch && typeof branch === 'string' && `--branch ${branch}`],
-            ...[branch && branch === true && '--branch'],
+            ...[all && '--all'],
+            ...[typeof branch === 'string' && `--branch ${branch}`],
             ...[count && `--count ${count}`],
+            ...[dry && '--dry'],
+            ...[registry && `--registry ${registry}`],
         ].filter(item => !!item) as string[];
     }
 }

package/src/cli/commands/types.ts

@@ -2,3 +2,5 @@ export interface Command {
     execute(): Promise<void>;
     description(): string | undefined;
 }
+
+export type Newable<T> = new (...args: any[]) => T;

package/src/cli/index.ts

@@ -20,7 +20,7 @@ if (!Command) {
     process.exit(127);
 }
 
-maybeCreateGitFolder();
+maybeCreateGitFolder(Command);
 
 if (setNodeOptions(name)) {
     // Run command in child process with amended NODE_OPTIONS

package/src/cli/utils/__tests__/cli-npm.test.ts

@@ -1,11 +1,10 @@
 import { runCommand, runCommandOutput } from '../cli-os';
 
 import {
-    npmGetPackageVersionDates,
     npmGetPackageVersions,
+    npmGetPackageVersionsDetails,
     npmPackageSet,
     npmPublish,
-    npmPublishDry,
     npmTagVersion,
     npmUnpublish,
 } from '../cli-npm';
@@ -48,7 +47,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     }
 
-    describe(`${npmGetPackageVersions.name}`, () => {
+    describe(npmGetPackageVersions.name, () => {
         let args: Parameters<typeof npmGetPackageVersions>;
 
         beforeEach(() => (args = ['{registry}', '{packageName}']));
@@ -82,30 +81,42 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
-    describe(`${npmGetPackageVersionDates.name}`, () => {
-        let args: Parameters<typeof npmGetPackageVersionDates>;
+    describe(npmGetPackageVersionsDetails.name, () => {
+        let args: Parameters<typeof npmGetPackageVersionsDetails>;
 
-        beforeEach(() => (args = ['{registry}', '{packageName}']));
+        beforeEach(() => {
+            jest.useFakeTimers();
+            args = ['{registry}', '{packageName}'];
+        });
 
-        const subject = () => npmGetPackageVersionDates(...args);
+        afterEach(() => jest.useRealTimers());
 
-        itRunsCommandOutput(subject, 'npm view {packageName} time --registry {registry} --json', {
-            timeout: 10000,
-        });
+        const subject = () => npmGetPackageVersionsDetails(...args);
+
+        itRunsCommandOutput(
+            subject,
+            'npm view {packageName} time dist-tags --registry {registry} --json',
+            { timeout: 10000 }
+        );
 
-        test('converts results to Array<[string, Date]>', () => {
+        test('converts results to Version[]', () => {
             function dayAgo(count: number) {
                 const date = new Date();
                 date.setDate(-count);
                 return date;
             }
-            const result = { '1.0.1': dayAgo(3), '2.1.0': dayAgo(2), '3.0.0': dayAgo(1) };
+            const result = {
+                'time': { '1.0.1': dayAgo(3), '2.1.0': dayAgo(2), '3.0.0': dayAgo(1) },
+                'dist-tags': { latest: '3.0.0' },
+            };
 
             jest.mocked(runCommandOutput).mockReturnValue(JSON.stringify(result));
 
-            expect(subject()).toEqual(
-                Object.entries(result).map(([version, date]) => [version, date])
-            );
+            expect(subject()).toEqual([
+                { name: '1.0.1', date: dayAgo(3) },
+                { name: '2.1.0', date: dayAgo(2) },
+                { name: '3.0.0', date: dayAgo(1), tag: 'latest' },
+            ]);
         });
 
         describe('when an error occurs', () => {
@@ -121,7 +132,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         });
     });
 
-    describe(`${npmPackageSet.name}`, () => {
+    describe(npmPackageSet.name, () => {
         let args: Parameters<typeof npmPackageSet>;
 
         beforeEach(() => (args = ['{key}', '{value}']));
@@ -131,27 +142,29 @@ describe('[startup] Cli Utils (Npm)', () => {
         itRunsCommand(subject, 'npm pkg set {key}={value}');
     });
 
-    describe(`${npmPublish.name}`, () => {
-        let args: Parameters<typeof npmPublish>;
+    describe(npmPublish.name, () => {
+        let options: Parameters<typeof npmPublish>[0];
 
-        beforeEach(() => (args = []));
+        beforeEach(() => (options = {}));
 
-        const subject = async () => npmPublish(...args);
+        const subject = async () => npmPublish(options);
 
         itRunsCommand(subject, 'npm publish');
 
         describe('with a tag', () => {
-            beforeEach(() => args.push('{tag}'));
+            beforeEach(() => (options.tag = '{tag}'));
 
             itRunsCommand(subject, 'npm publish --tag {tag}');
         });
-    });
 
-    describe(`${npmPublishDry.name}`, () => {
-        itRunsCommand(npmPublishDry, 'npm publish --dry-run');
+        describe('with {dry: true}', () => {
+            beforeEach(() => (options.dry = true));
+
+            itRunsCommand(subject, 'npm publish --dry-run');
+        });
     });
 
-    describe(`${npmUnpublish.name}`, () => {
+    describe(npmUnpublish.name, () => {
         let args: Parameters<typeof npmUnpublish>;
 
         beforeEach(() => (args = ['{registry}', '{packageName}', '{packageVersion}']));
@@ -165,7 +178,7 @@ describe('[startup] Cli Utils (Npm)', () => {
         );
     });
 
-    describe(`${npmTagVersion.name}`, () => {
+    describe(npmTagVersion.name, () => {
         let args: Parameters<typeof npmTagVersion>[0];
 
         beforeEach(() => {

package/src/cli/utils/__tests__/maybe-create-git-folder.test.ts

@@ -1,18 +1,32 @@
 import { fs, vol } from 'memfs';
 
 import { maybeCreateGitFolder } from '../maybe-create-git-folder';
+import { Init } from '../../commands/init';
+import { Start } from '../../commands/start';
 
 jest.mock('fs', () => fs);
 
 describe(`[startup] Utils`, () => {
     describe(`${maybeCreateGitFolder.name}`, () => {
+        let command: Parameters<typeof maybeCreateGitFolder>[0];
         const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
 
-        beforeEach(() => vol.fromJSON({}));
+        beforeEach(() => {
+            command = Start;
+            vol.fromJSON({});
+        });
 
         afterEach(() => vol.reset);
 
-        const subject = () => maybeCreateGitFolder();
+        const subject = () => maybeCreateGitFolder(command);
+
+        function itDoesNotCreateGitFolder() {
+            test('does not create .git folder', () => {
+                subject();
+
+                expect(mkdirSpy).not.toHaveBeenCalledWith();
+            });
+        }
 
         describe('when running on Windows', () => {
             beforeEach(() => {
@@ -24,6 +38,12 @@ describe(`[startup] Utils`, () => {
 
                 expect(mkdirSpy).toHaveBeenCalledWith('.git');
             });
+
+            describe('when command is Init', () => {
+                beforeEach(() => (command = Init));
+
+                itDoesNotCreateGitFolder();
+            });
         });
 
         describe('when not running on Windows', () => {
@@ -31,11 +51,7 @@ describe(`[startup] Utils`, () => {
                 Object.defineProperty(process, 'platform', { value: 'linux' });
             });
 
-            test('does not create .git folder', () => {
-                subject();
-
-                expect(mkdirSpy).not.toHaveBeenCalledWith();
-            });
+            itDoesNotCreateGitFolder();
         });
     });
 });

package/src/cli/utils/cli-npm.ts

@@ -1,10 +1,18 @@
 import { runCommand, runCommandOutput } from './cli-os';
 
+export interface Version {
+    name: string;
+    date: Date;
+    tag?: string;
+}
+
+const NPM_TIMEOUT = 10000;
+
 export function npmGetPackageVersions(registry: string, packageName: string): string[] {
     try {
         const v = runCommandOutput(
             `npm show ${packageName} versions --registry ${registry} --json`,
-            { timeout: 10000 }
+            { timeout: NPM_TIMEOUT }
         );
 
         return JSON.parse(v);
@@ -13,17 +21,22 @@ export function npmGetPackageVersions(registry: string, packageName: string): st
     }
 }
 
-export function npmGetPackageVersionDates(registry: string, packageName: string): [string, Date][] {
+export function npmGetPackageVersionsDetails(registry: string, packageName: string): Version[] {
     try {
-        const v = runCommandOutput(`npm view ${packageName} time --registry ${registry} --json`, {
-            timeout: 10000,
-        });
-        const map = JSON.parse(v);
+        const result = runCommandOutput(
+            `npm view ${packageName} time dist-tags --registry ${registry} --json`,
+            { timeout: NPM_TIMEOUT }
+        );
 
-        return Object.keys(map).reduce(
-            (out, version) => [...out, [version, new Date(map[version])]],
-            []
+        const { time, 'dist-tags': distTags } = JSON.parse(result);
+
+        const tags = Object.fromEntries(
+            Object.entries(distTags).map(([tag, version]) => [version, tag])
         );
+
+        return Object.keys(time).reduce((out, version) => {
+            return [...out, { name: version, date: new Date(time[version]), tag: tags[version] }];
+        }, []);
     } catch {
         return [];
     }
@@ -31,16 +44,12 @@ export function npmGetPackageVersionDates(registry: string, packageName: string)
 
 export async function npmUnpublish(registry: string, packageName: string, packageVersion: string) {
     await runCommand(`npm unpublish ${packageName}@${packageVersion} --registry ${registry}`, {
-        timeout: 10000,
+        timeout: NPM_TIMEOUT,
     });
 }
 
-export async function npmPublishDry() {
-    await runCommand('npm publish --dry-run');
-}
-
-export async function npmPublish(tag?: string) {
-    await runCommand(['npm publish', !!tag && `--tag ${tag}`]);
+export async function npmPublish({ dry, tag }: { dry?: boolean; tag?: string }) {
+    await runCommand(['npm publish', !!tag && `--tag ${tag}`, !!dry && `--dry-run`]);
 }
 
 export async function npmPackageSet(key: string, value: string) {

package/src/cli/utils/maybe-create-git-folder.ts

@@ -1,5 +1,8 @@
 import fs from 'fs';
 
+import { Init } from '../commands/init';
+import { Command, Newable } from '../commands/types';
+
 /**
  * Create empty .git folder to workaround issue where Lerna does not
  * detect workspace packages on Windows systems. The empty .git folder
@@ -8,10 +11,13 @@ import fs from 'fs';
  * keeps reappearing (e.g., https://github.com/nrwl/nx/issues/9584 and
  * https://github.com/nrwl/nx/issues/18094)
  */
-export function maybeCreateGitFolder() {
+export function maybeCreateGitFolder(command: Newable<Command>) {
     if (process.platform !== 'win32') {
         return;
     }
+    if (command === Init) {
+        return;
+    }
     if (!fs.existsSync('.git')) {
         fs.mkdirSync('.git');
     }