@servicetitan/startup 32.2.0 → 32.3.1

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

@@ -3,6 +3,8 @@ import { lernaExec } from '../../utils';
 import { Package, PackageType, getPackages } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
 
+import { MFEPackageClean } from '../mfe-package-clean';
+import { MFEPackagePublish } from '../mfe-package-publish';
 import { MFEPublish } from '../mfe-publish';
 
 jest.mock('fs', () => fs);
@@ -209,4 +211,27 @@ describe(`[startup] ${MFEPublish.name}`, () => {
             });
         });
     });
+
+    describe('options', () => {
+        const subject = () => MFEPublish.options;
+
+        test('groups publish and clean options', () => {
+            expect(subject()).toEqual(
+                expect.objectContaining({
+                    ...Object.fromEntries(
+                        Object.entries(MFEPackagePublish.options).map(([key, value]) => [
+                            key,
+                            { group: 'Publish Options:', ...value },
+                        ])
+                    ),
+                    ...Object.fromEntries(
+                        Object.entries(MFEPackageClean.options).map(([key, value]) => [
+                            Object.hasOwn(MFEPackagePublish.options, key) ? `${key}\u00A0` : key,
+                            { group: 'Clean Options:', ...value },
+                        ])
+                    ),
+                })
+            );
+        });
+    });
 });

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

@@ -83,7 +83,7 @@ describe(`[startup] ${Start.name}`, () => {
     }
 
     test('command is greedy', () => {
-        expect(new Start(args).greedy).toBe(true);
+        expect(Start.greedy).toBe(true);
     });
 
     describe('with TSC package', () => {

package/src/cli/commands/build.ts

@@ -1,9 +1,9 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
 import { checkArgs, compile, lernaExec, typeCheck, ProcessTree } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     'cdn-path'?: string;
     'code-coverage'?: boolean;
     'config'?: string;
@@ -22,14 +22,18 @@ enum BuildProcesses {
     BundlePackage,
 }
 
-export class Build implements Command {
-    readonly greedy = true;
-
-    constructor(private readonly args: Args) {}
-
-    description() {
-        return 'build project for production';
-    }
+export class Build extends Command<Args> {
+    static readonly description = 'Build project for production';
+    static readonly greedy = true;
+    static readonly options = {
+        'cdn-path': { string: true, description: 'Base url for application assets' },
+        'code-coverage': { boolean: true, description: 'Instrument code for coverage analysis?' },
+        'config': { string: true, hidden: true, description: 'Use specified configuration' },
+        'ignore': { array: true, description: 'Packages to skip' },
+        'scope': { array: true, description: 'Packages to build' },
+        'stat': { boolean: true, description: 'Generate bundle report?' },
+        'use-tsc': { boolean: true, description: 'Use tsc to compile packages?' },
+    };
 
     @logErrors
     async execute() {

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

@@ -1,21 +1,27 @@
 import { getTsConfig, log, logErrors } from '../../utils';
 import { bundle, getModuleType } from '../utils';
-import { Command } from '.';
+import { Command, CommandArgs } from './types';
 
-interface Args {
-    'config'?: string;
-    'code-coverage'?: boolean;
-    'exposed-dependencies'?: boolean;
-    'stat'?: boolean;
-    'watch'?: boolean;
+interface Args extends CommandArgs {
+    codeCoverage?: boolean;
+    config?: string;
+    exposedDependencies?: boolean;
+    stat?: boolean;
+    useWatchConfig?: boolean;
+    watch?: boolean;
 }
 
-export class BundlePackage implements Command {
-    constructor(private readonly args: Args) {}
-
+export class BundlePackage extends Command<Args> {
     @logErrors
     async execute() {
-        const { config, stat = false, watch } = this.args;
+        const {
+            config,
+            codeCoverage,
+            exposedDependencies: emitExposedDependencies,
+            stat = false,
+            useWatchConfig,
+            watch,
+        } = this.args;
 
         if (getModuleType(getTsConfig()) !== 'esnext') {
             log.warning(
@@ -23,11 +29,11 @@ export class BundlePackage implements Command {
             );
         }
 
-        const emitExposedDependencies = this.args['exposed-dependencies'];
         const options: Parameters<typeof bundle>[0] = {
             ...(emitExposedDependencies ? {} : { config }),
-            codeCoverage: this.args['code-coverage'],
+            codeCoverage,
             emitExposedDependencies,
+            useWatchConfig,
         };
 
         await bundle({ buildStat: stat, ...options, watch });

package/src/cli/commands/clean.ts

@@ -2,10 +2,8 @@ import { exec, execSync } from 'child_process';
 import { log, logErrors } from '../../utils';
 import { Command } from './types';
 
-export class Clean implements Command {
-    description() {
-        return 'reset project to fresh state';
-    }
+export class Clean extends Command {
+    static readonly description = 'Reset project to fresh state';
 
     @logErrors
     async execute() {

package/src/cli/commands/convert-eslint-config.ts

@@ -40,7 +40,9 @@ interface Recipe {
     import: { as: string; from?: string };
 }
 
-export class ConvertEslintConfig implements Command {
+export class ConvertEslintConfig extends Command {
+    static readonly description = 'Convert v8.x eslintrc.json to v9.x flat config';
+
     private static readonly recipes: Record<string, Recipe | null> = {
         '@servicetitan/eslint-config/mono': {
             import: { as: 'mono' },
@@ -74,10 +76,6 @@ export class ConvertEslintConfig implements Command {
         'prettier': null,
     };
 
-    description() {
-        return 'convert v8.x eslintrc.json to v9.x flat config';
-    }
-
     @logErrors
     async execute() {
         if (!fs.existsSync(oldConfigFile)) {

package/src/cli/commands/eslint.ts

@@ -1,16 +1,14 @@
-import { Command } from '.';
 import { logErrors } from '../../utils';
 import { eslint } from '../utils';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     // eslint-disable-next-line @typescript-eslint/naming-convention
     _: string[];
     fix?: boolean;
 }
 
-export class ESLintCommand implements Command {
-    constructor(private readonly args: Args) {}
-
+export class ESLintCommand extends Command<Args> {
     @logErrors
     async execute() {
         const { _: paths, fix } = this.args;

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

@@ -9,6 +9,7 @@ import { Init } from './init';
 import { Install } from './install';
 import { KendoUILicense } from './kendo-ui-license';
 import { Lint } from './lint';
+import { MFEList } from './mfe-list';
 import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
 import { MFEPublish } from './mfe-publish';
@@ -31,6 +32,7 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName.install]: Install,
     [CommandName['kendo-ui-license']]: KendoUILicense,
     [CommandName.lint]: Lint,
+    [CommandName['mfe-list']]: MFEList,
     [CommandName['mfe-package-clean']]: MFEPackageClean,
     [CommandName['mfe-package-publish']]: MFEPackagePublish,
     [CommandName['mfe-publish']]: MFEPublish,

package/src/cli/commands/index.ts

@@ -2,7 +2,6 @@ export * from './build';
 export * from './bundle-package';
 export * from './eslint';
 export * from './get-command';
-export * from './get-user-commands';
 export * from './init';
 export * from './install';
 export * from './kendo-ui-license';

package/src/cli/commands/init.ts

@@ -3,20 +3,19 @@ import path from 'path';
 
 import { log, logErrors } from '../../utils';
 import { gitCloneRepo, gitIsReachable } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     output?: string;
 }
 
 const REPO_NAME = 'frontend-example';
 
-export class Init implements Command {
-    constructor(private readonly args: Args) {}
-
-    description() {
-        return 'create example project';
-    }
+export class Init extends Command<Args> {
+    static readonly description = 'Create example project';
+    static readonly options = {
+        output: { string: true, description: 'Output path' },
+    };
 
     @logErrors
     async execute() {

package/src/cli/commands/install.ts

@@ -3,12 +3,12 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { log, logErrors, getStartupVersion, readJsonSafe } from '../../utils';
-import { Command } from './types';
-import { gitCloneRepo, isCI } from '../utils';
+import { Command, CommandArgs } from './types';
+import { gitCloneRepo, isCI, npmWhoAmI } from '../utils';
 
-interface Args {
-    quiet?: boolean;
+interface Args extends CommandArgs {
     fix?: boolean;
+    quiet?: boolean;
     token?: boolean;
 }
 
@@ -16,12 +16,13 @@ const REPO_NAME = 'frontend-dev-config';
 const AUTH_TOKEN_KEY = '//registry.npmjs.org/:_authToken';
 const AUTH_TOKEN_REGEX = /^\/\/registry\.npmjs\.org\/:_authToken=\s*\${([^}]+)}/m;
 
-export class Install implements Command {
-    constructor(private readonly args?: Args) {}
-
-    description() {
-        return 'install project dependencies';
-    }
+export class Install extends Command<Args> {
+    static readonly description = 'Install project dependencies';
+    static readonly options = {
+        fix: { boolean: true, describe: 'Update and dedupe package-lock.json', hidden: true },
+        quite: { boolean: true, describe: 'Suppress output', hidden: true },
+        token: { boolean: true, describe: 'Configure npm token' },
+    };
 
     @logErrors
     async execute() {
@@ -30,7 +31,10 @@ export class Install implements Command {
         }
 
         const env = await this.configureNpmToken();
-        this.installPackages(env);
+
+        if (this.args?.token !== true) {
+            this.installPackages(env);
+        }
 
         return Promise.resolve(); // stops "async method has no 'await' expression" lint error
     }
@@ -44,6 +48,15 @@ export class Install implements Command {
             log.info('Configuring NPM token ...');
         }
 
+        if (this.args?.token !== true) {
+            const npmUser = npmWhoAmI();
+            /* istanbul ignore next: debug only */
+            log.debug('install:npm-user', () => JSON.stringify({ npmUser }));
+            if (npmUser === 'st-team') {
+                return;
+            }
+        }
+
         const token = await this.fetchNpmToken();
         if (!token) {
             return;

package/src/cli/commands/kendo-ui-license.ts

@@ -2,7 +2,7 @@ import execa from 'execa';
 
 import { log, logErrors } from '../../utils';
 import { isModuleInstalled } from '../utils';
-import { Command } from '.';
+import { Command } from './types';
 
 const ENCODED_LICENSE = `
     ZXlKaGJHY2lPaUpTVXpJMU5pSXNJblI1Y0NJNklreEpReUo5LmV5SndjbTlrZFdOMGN5STZXM3Np
@@ -29,10 +29,8 @@ const ENVIRONMENT_VARIABLE = 'KENDO_UI_LICENSE';
 const LICENSE = Buffer.from(ENCODED_LICENSE, 'base64').toString('ascii');
 const LICENSING_PACKAGE = '@progress/kendo-licensing';
 
-export class KendoUILicense implements Command {
-    description() {
-        return 'install KendoReact license key';
-    }
+export class KendoUILicense extends Command {
+    static readonly description = 'Install KendoReact license key';
 
     async execute() {
         if (!isModuleInstalled(LICENSING_PACKAGE)) {
@@ -66,5 +64,5 @@ export class KendoUILicense implements Command {
 }
 
 export async function kendoUILicense() {
-    return new KendoUILicense().execute();
+    return new KendoUILicense({}).execute();
 }

package/src/cli/commands/lint.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import path from 'path';
 
 import stylelint from 'stylelint';
@@ -9,34 +10,28 @@ import {
     log,
     logErrors,
 } from '../../utils';
-import { Command } from '.';
+import { Command, CommandArgs } from './types';
 import { eslint, lernaExec } from '../utils';
 
-interface Args {
-    // eslint-disable-next-line @typescript-eslint/naming-convention
+interface Args extends CommandArgs {
     _: string[];
-    /** Apply fixes for issues? */
     fix?: boolean;
-    /** Packages to lint */
     scope?: string | string[];
-    /** Packages to skip */
     ignore?: string | string[];
-    /** Run eslint separately for each package? */
     parallel?: boolean;
+    paths?: string[];
 }
 
-export class Lint implements Command {
-    readonly greedy = true;
-
-    private readonly paths: string[];
-
-    constructor(private readonly args: Args) {
-        this.paths = [...args._];
-    }
-
-    description() {
-        return 'run eslint and stylelint';
-    }
+export class Lint extends Command<Args> {
+    static readonly description = 'Run eslint and stylelint';
+    static readonly greedy = true;
+    static readonly options = {
+        _: { description: '[paths...]' },
+        fix: { boolean: true, description: 'Apply fixes for issues?' },
+        scope: { array: true, hidden: true, description: 'Packages to lint' },
+        ignore: { array: true, hidden: true, description: 'Packages to skip' },
+        parallel: { boolean: true, hidden: true, description: 'Lint each package separately' },
+    };
 
     async execute() {
         await this.checkStyles();
@@ -127,6 +122,11 @@ export class Lint implements Command {
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         return !this.paths.length && (parallel || scope?.length || ignore?.length);
     }
+
+    private get paths() {
+        const { _, paths = [] } = this.args;
+        return [..._, ...paths];
+    }
 }
 
 function pathUniJoin(...chunks: string[]) {

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

@@ -0,0 +1,173 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import readline from 'readline/promises';
+import {
+    formatRelativeDate,
+    getPackages,
+    isWebComponent,
+    log,
+    logErrors,
+    PackageType,
+} from '../../utils';
+import { Command, CommandArgs } from './types';
+import { isTTY, NPMPackageInfo, npmView, npmWhoAmI, runCommand } from '../utils';
+
+interface Args extends CommandArgs {
+    _: string[];
+    all?: boolean;
+    ignore?: string | string[];
+    limit?: number;
+    packageNames?: string[];
+    registry?: string;
+    tagged?: boolean;
+}
+
+const collator = new Intl.Collator();
+
+const VERDACCIO = 'https://verdaccio.servicetitan.com';
+
+export class MFEList extends Command<Args> {
+    static readonly description = 'List published MFE packages';
+    static readonly options = {
+        _: { description: '[packageNames...]' },
+        all: { boolean: true, description: 'List all published versions ' },
+        ignore: {
+            array: true,
+            description: 'Exclude MFEs with names matching specified glob pattern ',
+        },
+        limit: {
+            number: true,
+            description: 'List only the specified number of published versions',
+        },
+        tagged: { boolean: true, description: 'List only tagged versions' },
+    };
+
+    @logErrors
+    async execute() {
+        await this.login();
+
+        this.packageNames.forEach((name, index) => {
+            const info = npmView({ packageName: name, registry: this.registry });
+            if (info) {
+                if (index > 0) {
+                    process.stdout.write('\n');
+                }
+
+                process.stdout.write(this.getCaption(info) + '\n');
+                const table = this.getTable(info);
+                if (table) {
+                    process.stdout.write(table + '\n');
+                }
+            }
+        });
+    }
+
+    private getCaption(info: NPMPackageInfo) {
+        return [
+            chalk.bold.cyan(info.name),
+            info.version && `version: ${info.version}`,
+            `versions: ${Object.keys(this.getTime(info)).length}`,
+        ]
+            .filter(el => !!el)
+            .join(' | ');
+    }
+
+    private getTable(info: NPMPackageInfo) {
+        const times = Object.entries(this.getTime(info)).sort(
+            ([, a], [, b]) => -1 * collator.compare(a, b)
+        );
+        const versionTags = this.getVersionTags(info);
+        const versions = this.args.tagged
+            ? times.filter(([version]) => !!versionTags[version])
+            : times.slice(0, this.limit);
+
+        /* istanbul ignore next: debug only */
+        log.debug('mfe-list', () =>
+            JSON.stringify({ name: info.name, versionTags, versions }, null, 2)
+        );
+
+        if (versions.length === 0) {
+            return '';
+        }
+
+        const table = new Table({
+            head: ['Version', 'Tag', 'When'].map(title => chalk.bold.cyan(title)),
+            style: { head: [] },
+        });
+
+        versions.forEach(([version, timestamp]) => {
+            const when = formatRelativeDate(new Date(timestamp));
+            const tag = (versionTags[version] ?? []).join(', ');
+            table.push([version, chalk.bold.cyan(tag), when]);
+        });
+
+        return table.toString();
+    }
+
+    private getTime(info: NPMPackageInfo) {
+        const { time: { created, modified, ...time } = {} } = info;
+        return time;
+    }
+
+    private getVersionTags({ 'dist-tags': distTags = {} }: NPMPackageInfo) {
+        return Object.entries(distTags).reduce<Record<string, string[]>>(
+            (result, [name, version]) => {
+                result[version] ??= [];
+                result[version].push(name);
+                return result;
+            },
+            {}
+        );
+    }
+
+    private async ask(question: string) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const answer = await rl.question(question);
+        rl.close();
+        return answer.trim().toLowerCase();
+    }
+
+    private async login() {
+        if (this.registry !== VERDACCIO || npmWhoAmI({ registry: this.registry }) !== undefined) {
+            return;
+        }
+
+        const message = `This machine is not authorized to access ${this.registry}.`;
+        if (!isTTY()) {
+            throw new Error(message);
+        }
+
+        const answer = await this.ask(chalk.bold.cyan(`${message} Authorize? [Y/n] `));
+        if (answer && answer !== 'y') {
+            throw new Error('Not authorized');
+        }
+
+        await runCommand(`npx --yes verdaccio-okta-oauth@latest --registry=${this.registry}`, {
+            quiet: true,
+        });
+    }
+
+    private get limit() {
+        if (this.args.all) {
+            return Number.MAX_SAFE_INTEGER;
+        }
+        return this.args.limit && this.args.limit > 0 ? this.args.limit : 20;
+    }
+
+    private get packageNames() {
+        const { _, packageNames = [] } = this.args;
+        if (_.length || packageNames.length) {
+            return [..._, ...packageNames];
+        }
+
+        return getPackages({ ignore: this.args.ignore, type: PackageType.Webpack })
+            .filter(isWebComponent)
+            .map(({ name }) => name)
+            .sort((a, b) => collator.compare(a, b));
+    }
+
+    private get registry() {
+        return this.args.registry ?? VERDACCIO;
+    }
+}

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

@@ -1,8 +1,8 @@
 import { getBranchesConfigs, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-export interface Args {
+export interface Args extends CommandArgs {
     all?: true;
     branch?: string;
     count?: number;
@@ -10,8 +10,29 @@ export interface Args {
     registry?: string;
 }
 
-export class MFEPackageClean implements Command {
-    constructor(private readonly args: Args) {}
+export class MFEPackageClean extends Command<Args> {
+    static readonly options = {
+        all: {
+            boolean: true,
+            description: 'Unpublish old versions from all branches',
+            defaultDescription: 'false',
+        },
+        branch: {
+            string: true,
+            description: 'Branch name of versions to unpublish',
+            defaultDescription: 'current git branch',
+        },
+        count: {
+            number: true,
+            description: 'Keep the specified number of old versions',
+            defaultDescription: '5',
+        },
+        dry: {
+            boolean: true,
+            description: 'Take no action and only log what would be unpublished',
+        },
+        registry: { string: true, hidden: true, description: 'Registry url' },
+    };
 
     @logErrors
     async execute() {

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

@@ -19,9 +19,9 @@ import {
     npmTagVersion,
     runCommand,
 } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-export interface Args {
+export interface Args extends CommandArgs {
     branch?: string;
     build?: string;
     dry?: boolean;
@@ -49,8 +49,37 @@ interface PackageJson {
     files?: string[];
 }
 
-export class MFEPackagePublish implements Command {
-    constructor(private readonly args: Args) {}
+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',
+        },
+    };
 
     @logErrors
     async execute() {