@servicetitan/startup 33.1.1 → 34.0.0

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

@@ -1,5 +1,5 @@
-import path from 'path';
 import fs from 'fs';
+import path from 'path';
 import {
     getBranchesConfigs,
     getFolders,
@@ -10,6 +10,7 @@ import {
 } from '../../utils';
 import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
 import {
+    DRY_RUN_PREFIX,
     getDefaultBuildVersion,
     gitGetBranch,
     gitGetCommitHash,
@@ -17,30 +18,60 @@ import {
     npmPackageSet,
     npmPublish,
     npmTagVersion,
+    npmView,
     runCommand,
 } from '../utils';
-import { Command, CommandArgs } from './types';
-
-export interface Args extends CommandArgs {
-    branch?: string;
-    build?: string;
-    dry?: boolean;
-    force?: boolean;
-    registry?: string;
-    tag?: string;
-    uploadSourcemaps?: boolean;
-}
+import { Command, CommandOptions } from './types';
+import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+
+export const mfePackagePublishOptions = {
+    branch: {
+        string: true,
+        description: 'Branch name to associate with published version',
+        defaultDescription: 'current git branch',
+    },
+    build: {
+        string: true,
+        description: 'Package version',
+        defaultDescription: '<branch_name>.<commit_hash>',
+    },
+    dry: {
+        boolean: true,
+        description: 'Take no action and only log what would be published',
+    },
+    force: {
+        boolean: true,
+        description: 'Force publishing from an unrecognized branch',
+    },
+    registry: { string: true, hidden: true, description: 'Registry url' },
+    trackHistory: {
+        boolean: true,
+        description: `Tag the previous release, to support rollbacks`,
+        defaultDescription: 'true',
+        hidden: true,
+    },
+    tag: {
+        string: true,
+        description: 'Tag to assign to published version',
+    },
+    uploadSourcemaps: {
+        boolean: true,
+        description: 'Upload source maps to Datadog?',
+        defaultDescription: 'true',
+    },
+} satisfies CommandOptions;
 
 interface PublishData {
     buildVersion: string;
     dry: boolean;
-    fallbackTag: string;
     force: boolean;
     isBranchConfigured: boolean;
     registry: string;
     tag: string;
     uploadSourcemaps: boolean;
     version: string;
+    trackHistory: boolean;
+    publishedTags: Record<string, string>;
 }
 
 interface PackageJson {
@@ -49,37 +80,8 @@ interface PackageJson {
     files?: string[];
 }
 
-export class MFEPackagePublish extends Command<Args> {
-    static readonly options = {
-        'branch': {
-            string: true,
-            description: 'Branch name to associate with published version',
-            defaultDescription: 'current git branch',
-        },
-        'build': {
-            string: true,
-            description: 'Package version',
-            defaultDescription: '<branch_name>.<commit_hash>',
-        },
-        'dry': {
-            boolean: true,
-            description: 'Take no action and only log what would be published',
-        },
-        'force': {
-            boolean: true,
-            description: 'Force publishing from an unrecognized branch',
-        },
-        'registry': { string: true, hidden: true, description: 'Registry url' },
-        'tag': {
-            string: true,
-            description: 'Tag to assign to published version',
-        },
-        'upload-source-maps': {
-            boolean: true,
-            description: 'Upload source maps to Datadog?',
-            defaultDescription: 'true',
-        },
-    };
+export class MFEPackagePublish extends Command<typeof mfePackagePublishOptions> {
+    static readonly options = mfePackagePublishOptions;
 
     @logErrors
     async execute() {
@@ -88,14 +90,15 @@ export class MFEPackagePublish extends Command<Args> {
         }
 
         const packageJson = readJson<PackageJson>('package.json');
-        const data = this.getPublishData();
+
+        const data = this.getPublishData(packageJson.name);
         if (!this.checkPackage(packageJson, data)) {
             return;
         }
 
-        if (!(await this.tryTagExistingVersion(packageJson, data))) {
-            await this.publishPackage(packageJson, data);
-        }
+        await this.maybeApplyRollbackTag(packageJson.name, data);
+
+        await this.maybePublishPackage(packageJson, data);
 
         if (data.uploadSourcemaps) {
             this.uploadSourcemaps(data);
@@ -103,7 +106,7 @@ export class MFEPackagePublish extends Command<Args> {
     }
 
     private get dryRunPrefix() {
-        return this.args.dry ? '(dry-run) ' : '';
+        return this.args.dry ? DRY_RUN_PREFIX : '';
     }
 
     private checkPackage(packageJson: PackageJson, { force, isBranchConfigured }: PublishData) {
@@ -126,45 +129,53 @@ export class MFEPackagePublish extends Command<Args> {
         return true;
     }
 
-    private async tryTagExistingVersion(
-        { name }: PackageJson,
-        { dry, registry, tag, version }: PublishData
-    ) {
-        const versions = npmGetPackageVersions(registry, name);
-        if (!versions.includes(version)) {
-            return false;
-        }
-
-        log.warning(
-            `${this.dryRunPrefix}${name} version ${version} is already published, skipping publish`
-        );
+    private async maybePublishPackage(packageJson: PackageJson, data: PublishData) {
+        try {
+            const { dry, registry, tag, version } = data;
+
+            const versions = npmGetPackageVersions(registry, packageJson.name);
+            if (versions.includes(version)) {
+                log.warning(
+                    `${this.dryRunPrefix}${packageJson.name} version ${version} is already published, skipping publish`
+                );
+
+                log.info(`${this.dryRunPrefix}Tagging version ${version} with tag "${tag}"`);
+
+                if (!dry) {
+                    await npmTagVersion({
+                        packageName: packageJson.name,
+                        packageVersion: version,
+                        registry,
+                        tag,
+                    });
+                }
 
-        if (tag) {
-            log.info(`${this.dryRunPrefix}adding tag "${tag}" to ${name} version ${version}`);
-            if (!dry) {
-                await npmTagVersion({
-                    packageName: name,
-                    packageVersion: version,
-                    registry,
-                    tag,
-                });
+                return;
             }
-        }
-        return true;
-    }
 
-    private async publishPackage(
-        packageJson: PackageJson,
-        { dry, fallbackTag, registry, tag, version }: PublishData
-    ) {
-        this.validateMetadata(version);
+            this.validateMetadata(version);
+
+            await npmPackageSet('version', version);
+            await npmPackageSet('publishConfig.registry', registry);
+            await this.setPackageFiles(packageJson);
 
-        await npmPackageSet('version', version);
-        await npmPackageSet('publishConfig.registry', registry);
-        await this.setPackageFiles(packageJson);
+            log.info(`${this.dryRunPrefix}Publishing ${packageJson.name} version ${version}`);
+            await npmPublish({ dry, tag });
+        } catch (error) {
+            log.error(`Failed to publish package ${packageJson.name}`);
 
-        await npmPublish({ dry, tag: tag || fallbackTag });
-        log.info(`${this.dryRunPrefix}published ${packageJson.name} version ${version}`);
+            const versionOriginallyTaggedWithRollback =
+                data.publishedTags[buildRollbackTag(data.tag)];
+
+            if (versionOriginallyTaggedWithRollback) {
+                await this.restoreRollbackTag(
+                    packageJson.name,
+                    data,
+                    versionOriginallyTaggedWithRollback
+                );
+            }
+            throw error;
+        }
     }
 
     private uploadSourcemaps({ dry, version }: PublishData) {
@@ -175,26 +186,28 @@ export class MFEPackagePublish extends Command<Args> {
         runCommand(`npx startup upload-sourcemaps ${options.join(' ')}`);
     }
 
-    private getPublishData(): PublishData {
+    private getPublishData(packageName: string): PublishData {
         const cli = this.args;
         const branch = cli.branch ?? gitGetBranch();
         const branchConfig = getBranchesConfigs()[branch];
 
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         const buildVersion = cli.build || getDefaultBuildVersion(branch, gitGetCommitHash());
-        const registry = cli.registry ?? 'https://verdaccio.servicetitan.com';
+        const registry = cli.registry ?? DEFAULT_MFE_REGISTRY;
         const tag = cli.tag ?? branchConfig?.publishTag ?? '';
         const uploadSourcemaps = cli.uploadSourcemaps ?? branchConfig?.uploadSourcemaps ?? true;
         const version = '0.0.0-' + buildVersion;
+        const publishedTags = npmView({ packageName, registry })?.['dist-tags'] ?? {};
 
         return {
             buildVersion,
             dry: !!cli.dry,
-            fallbackTag: 'latest',
             force: !!cli.force,
             isBranchConfigured: !!branchConfig,
+            publishedTags,
             registry,
-            tag,
+            tag: tag || 'latest',
+            trackHistory: cli.trackHistory ?? true,
             uploadSourcemaps,
             version,
         };
@@ -263,4 +276,57 @@ export class MFEPackagePublish extends Command<Args> {
             });
         });
     }
+
+    private async maybeApplyRollbackTag(packageName: string, data: PublishData) {
+        const { dry, registry, tag, trackHistory, version, publishedTags } = data;
+
+        if (!trackHistory) {
+            log.info('Track history is turned off, skipping rollback tag');
+            return;
+        }
+
+        const previousVersion = publishedTags[tag];
+
+        if (!previousVersion) {
+            log.info(`No previous version published with tag "${tag}", skipping rollback tag`);
+            return;
+        }
+
+        if (previousVersion === version) {
+            log.info(`Version "${version}" is already tagged "${tag}", skipping rollback tag`);
+            return;
+        }
+
+        const prevTag = buildRollbackTag(tag);
+
+        log.info(
+            `${this.dryRunPrefix}Tagging previous version ${previousVersion} with tag "${prevTag}"`
+        );
+
+        if (!dry) {
+            await npmTagVersion({
+                packageName,
+                packageVersion: previousVersion,
+                registry,
+                tag: prevTag,
+            });
+        }
+    }
+
+    private async restoreRollbackTag(
+        packageName: string,
+        { registry, tag }: PublishData,
+        version: string
+    ) {
+        const rollbackTag = buildRollbackTag(tag);
+
+        log.info(`Restoring rollback tag ${rollbackTag} back to version ${version}`);
+
+        await npmTagVersion({
+            packageName,
+            packageVersion: version,
+            registry,
+            tag: rollbackTag,
+        });
+    }
 }

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

@@ -0,0 +1,100 @@
+import { log, logErrors, readJson } from '../../utils';
+import { DRY_RUN_PREFIX, npmTagVersion, npmView } from '../utils';
+import { Command, CommandOptions } from './types';
+import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+
+export const mfePackageRollbackOptions = {
+    dry: {
+        boolean: true,
+        description: 'Take no action and only log what would be rolled back',
+    },
+    registry: {
+        string: true,
+        hidden: true,
+        description: 'Registry url',
+    },
+    tag: {
+        string: true,
+        description: 'The tag to rollback to its previous version',
+        required: true,
+    },
+} satisfies CommandOptions;
+
+interface PackageJson {
+    name: string;
+}
+
+export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions> {
+    static readonly description = 'Rollback a package to a previous tagged version';
+
+    static readonly options = mfePackageRollbackOptions;
+
+    private get dryRunPrefix() {
+        return this.args.dry ? DRY_RUN_PREFIX : '';
+    }
+
+    @logErrors
+    async execute() {
+        if (this.args.dry) {
+            log.warning('DRY-RUN MODE ENABLED, WILL NOT PERFORM ROLLBACK');
+        }
+
+        await this.handleRollback();
+    }
+
+    private async handleRollback() {
+        const { tag, registry = DEFAULT_MFE_REGISTRY, dry } = this.args;
+
+        const packageJson = readJson<PackageJson>('package.json');
+        const packageName = packageJson.name;
+
+        log.info(`${this.dryRunPrefix}Rolling back ${packageName} for tag "${tag}"`);
+
+        const packageInfo = npmView({ packageName, registry });
+        if (!packageInfo) {
+            throw new Error(`Package ${packageName} not found in registry`);
+        }
+
+        const distTags = packageInfo?.['dist-tags'] ?? {};
+
+        const rollbackTag = buildRollbackTag(tag);
+        const rollbackVersion = distTags[rollbackTag];
+
+        if (!rollbackVersion) {
+            throw new Error(
+                `No rollback version found for tag "${tag}" (looking for "${rollbackTag}")`
+            );
+        }
+
+        log.info(
+            `${this.dryRunPrefix}Found rollback version ${rollbackVersion} for tag "${rollbackTag}"`
+        );
+
+        const currentVersion = distTags[tag];
+        if (currentVersion === rollbackVersion) {
+            log.info(
+                `${this.dryRunPrefix}Tags "${tag}" and "${rollbackTag}" both point to version ${rollbackVersion}, skipping rollback`
+            );
+            return;
+        }
+
+        if (currentVersion) {
+            log.info(
+                `${this.dryRunPrefix}Current tag "${tag}" points to version ${currentVersion}`
+            );
+        }
+
+        log.info(
+            `${this.dryRunPrefix}Rolling back ${packageName} tag "${tag}" to version ${rollbackVersion}`
+        );
+
+        if (!dry) {
+            await npmTagVersion({
+                packageName,
+                packageVersion: rollbackVersion,
+                registry,
+                tag,
+            });
+        }
+    }
+}

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

@@ -1,19 +1,40 @@
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
-import { Args as CleanArgs, MFEPackageClean } from './mfe-package-clean';
-import { Args as PublishArgs, MFEPackagePublish } from './mfe-package-publish';
-import { Command } from './types';
 import { lernaExec } from '../utils';
+import { mfePackageCleanOptions } from './mfe-package-clean';
+import { mfePackagePublishOptions } from './mfe-package-publish';
+import { mfePackageRollbackOptions } from './mfe-package-rollback';
+import { Command, CommandOptions } from './types';
 
-interface Args extends PublishArgs, CleanArgs {
-    clean?: boolean;
-    concurrency?: number;
-    scope?: string | string[];
-}
+const mfePublishOwnOptions = {
+    clean: { boolean: true, description: 'Unpublish old versions' },
+    concurrency: {
+        number: true,
+        description: 'Publish/unpublish the specified number of packages concurrently',
+        defaultDescription: '1',
+    },
+    rollback: {
+        boolean: true,
+        description: 'Rollback specified tag to the previous version',
+    },
+    scope: {
+        array: true,
+        string: true,
+        description: 'Publish/unpublish only the specified packages',
+    },
+} satisfies CommandOptions;
+
+type MFEPublishOptions = typeof mfePublishOwnOptions &
+    typeof mfePackagePublishOptions &
+    typeof mfePackageCleanOptions &
+    // make 'tag' not required for mfe-publish args, since it is only required for rollback
+    Omit<typeof mfePackageRollbackOptions, 'tag'> & {
+        tag: Omit<typeof mfePackageRollbackOptions.tag, 'required'>;
+    };
 
-export class MFEPublish extends Command<Args> {
+export class MFEPublish extends Command<MFEPublishOptions> {
     static readonly description = 'Publish or unpublish MFE packages';
     static get options() {
-        const publishOptions = Object.entries(MFEPackagePublish.options).reduce(
+        const publishOptions = Object.entries(mfePackagePublishOptions).reduce(
             (result, [key, value]) => {
                 result[key] = { group: 'Publish Options:', ...value };
                 return result;
@@ -21,9 +42,10 @@ export class MFEPublish extends Command<Args> {
             {} as NonNullable<typeof Command.options>
         );
 
-        const cleanOptions = Object.entries(MFEPackageClean.options).reduce(
+        const cleanOptions = Object.entries(mfePackageCleanOptions).reduce(
             (result, [key, value]) => {
-                result[Object.hasOwn(publishOptions, key) ? `${key}\u00A0` : key] = {
+                // no-break space suffix prevents key collisions
+                result[`${key}\u00A0`] = {
                     group: 'Clean Options:',
                     ...value,
                 };
@@ -32,19 +54,26 @@ export class MFEPublish extends Command<Args> {
             {} as NonNullable<typeof Command.options>
         );
 
-        return {
-            clean: { boolean: true, description: 'Unpublish old versions' },
-            concurrency: {
-                number: true,
-                description: 'Publish/unpublish the specified number of packages concurrently',
-                defaultDescription: '1',
-            },
-            scope: {
-                array: true,
-                description: 'Publish/unpublish only the specified packages',
+        const rollbackOptions = Object.entries(mfePackageRollbackOptions).reduce(
+            (result, [key, value]) => {
+                const optionProps = Object.fromEntries(
+                    Object.entries(value).filter(([k]) => k !== 'required')
+                );
+                // double no-break space suffix prevents key collisions
+                result[`${key}\u00A0\u00A0`] = {
+                    group: 'Rollback Options:',
+                    ...optionProps,
+                };
+                return result;
             },
+            {} as NonNullable<typeof Command.options>
+        );
+
+        return {
+            ...mfePublishOwnOptions,
             ...publishOptions,
             ...cleanOptions,
+            ...rollbackOptions,
         };
     }
 
@@ -58,33 +87,57 @@ export class MFEPublish extends Command<Args> {
             throw new Error('no packages found for publication');
         }
 
+        const isRollback = !!this.args.rollback;
         const isClean = !!this.args.clean;
+
+        let cmdSuffix: string;
+        let options: string[];
+
+        if (isRollback) {
+            cmdSuffix = 'rollback';
+            options = this.getRollbackOptions();
+        } else {
+            cmdSuffix = isClean ? 'clean' : 'publish';
+            options = isClean ? this.getCleanOptions() : this.getPublishOptions();
+        }
+
         await lernaExec({
-            'cmd': `startup mfe-package-${isClean ? 'clean' : 'publish'}`,
+            'cmd': `startup mfe-package-${cmdSuffix}`,
             'parallel': this.args.concurrency ?? 1,
             'scope': packages.map(({ name }) => name),
             'stream': true,
-            '--': isClean ? this.getCleanOptions() : this.getPublishOptions(),
+            '--': options,
         });
     }
 
     getPublishOptions() {
-        const { build, branch, dry, force, registry, tag, uploadSourcemaps } = this
-            .args as PublishArgs;
+        const { build, branch, dry, force, registry, tag, uploadSourcemaps, trackHistory } =
+            this.args;
         return [
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[registry && `--registry ${registry}`],
+            ...[trackHistory === true && '--track-history'],
+            ...[trackHistory === false && '--no-track-history'],
             ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[uploadSourcemaps === true && `--upload-sourcemaps`],
             ...[uploadSourcemaps === false && `--no-upload-sourcemaps`],
         ].filter(item => !!item) as string[];
     }
 
+    getRollbackOptions() {
+        const { dry, registry, tag } = this.args;
+        return [
+            ...[dry && '--dry'],
+            ...[registry && `--registry ${registry}`],
+            ...[typeof tag === 'string' && `--tag ${tag}`],
+        ].filter(item => !!item) as string[];
+    }
+
     getCleanOptions() {
-        const { all, branch, count, dry, registry } = this.args as CleanArgs;
+        const { all, branch, count, dry, registry } = this.args;
         return [
             ...[all && '--all'],
             ...[typeof branch === 'string' && `--branch ${branch}`],

package/src/cli/commands/prepare-package.ts

@@ -1,12 +1,13 @@
 import { logErrors } from '../../utils';
 import { copyFiles } from '../utils';
-import { Command, CommandArgs } from './types';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    watch?: boolean;
-}
+const options = {
+    watch: { boolean: true, hidden: true },
+} satisfies CommandOptions;
 
-export class PreparePackage extends Command<Args> {
+export class PreparePackage extends Command<typeof options> {
+    static readonly options = options;
     @logErrors
     execute() {
         return copyFiles({ watch: this.args.watch });