@servicetitan/startup 32.1.0 → 32.3.0

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() {

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

@@ -1,6 +1,6 @@
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
-import { Args as CleanArgs } from './mfe-package-clean';
-import { Args as PublishArgs } from './mfe-package-publish';
+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';
 
@@ -10,11 +10,42 @@ interface Args extends PublishArgs, CleanArgs {
     scope?: string | string[];
 }
 
-export class MFEPublish implements Command {
-    constructor(private readonly args: Args) {}
+export class MFEPublish extends Command<Args> {
+    static readonly description = 'Publish or unpublish MFE packages';
+    static get options() {
+        const publishOptions = Object.entries(MFEPackagePublish.options).reduce(
+            (result, [key, value]) => {
+                result[key] = { group: 'Publish Options:', ...value };
+                return result;
+            },
+            {} as NonNullable<typeof Command.options>
+        );
+
+        const cleanOptions = Object.entries(MFEPackageClean.options).reduce(
+            (result, [key, value]) => {
+                result[Object.hasOwn(publishOptions, key) ? `${key}\u00A0` : key] = {
+                    group: 'Clean Options:',
+                    ...value,
+                };
+                return result;
+            },
+            {} as NonNullable<typeof Command.options>
+        );
 
-    description() {
-        return 'publish or unpublish MFE packages';
+        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',
+            },
+            ...publishOptions,
+            ...cleanOptions,
+        };
     }
 
     @logErrors

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

@@ -1,14 +1,12 @@
 import { logErrors } from '../../utils';
 import { copyFiles } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     watch?: boolean;
 }
 
-export class PreparePackage implements Command {
-    constructor(private readonly args: Args) {}
-
+export class PreparePackage extends Command<Args> {
     @logErrors
     execute() {
         return copyFiles({ watch: this.args.watch });

package/src/cli/commands/review/review.ts

@@ -9,7 +9,7 @@ import {
     readJsonSafe,
     toArray,
 } from '../../../utils';
-import { Command } from '../types';
+import { Command, CommandArgs } from '../types';
 
 import {
     ErrorSeverity,
@@ -33,12 +33,18 @@ import { rules } from './rules';
 
 const collator = new Intl.Collator();
 
-interface Args {
+interface Args extends CommandArgs {
     fix?: boolean;
     rule?: string | string[];
 }
 
-export class Review implements Command {
+export class Review extends Command<Args> {
+    static readonly description = 'Check project for configuration errors';
+    static readonly options = {
+        fix: { boolean: true, description: 'Fix detected problems' },
+        rule: { array: true, description: 'Limit checks to specified rule(s)' },
+    };
+
     private readonly severityToLabel: Record<ErrorSeverity, string> = {
         [ErrorSeverity.warning]: chalk.yellow('warning'),
         [ErrorSeverity.error]: chalk.red('error'),
@@ -49,12 +55,6 @@ export class Review implements Command {
         error: ErrorSeverity.error,
     };
 
-    constructor(private readonly args: Args) {}
-
-    description() {
-        return 'check project for configuration errors';
-    }
-
     @logErrors
     async execute() {
         const errors = this.args.fix ? this.fixErrors() : this.findErrors();

package/src/cli/commands/run-task.ts

@@ -1,33 +1,37 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { log, logErrors } from '../../utils';
-import { Command } from './types';
 import { SwcCompilePackage } from '../tasks/swc-compile-package';
 import { TscCompilePackage } from '../tasks/tsc-compile-package';
 import { TscCompile } from '../tasks/tsc-compile';
 import { Task } from '../tasks/task';
+import { Command, CommandArgs } from './types';
 
-interface Args {
-    [key: string]: unknown;
-    // eslint-disable-next-line @typescript-eslint/naming-convention
+interface Args extends CommandArgs {
     _: string[];
+    taskName?: string;
+    taskArgs?: string[];
 }
 
-const tasks: Record<string, new (args: Args) => Task> = {
+const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
     'tsc-compile-package': TscCompilePackage,
     'swc-compile-package': SwcCompilePackage,
     'tsc-compile': TscCompile,
 };
 
-export class RunTask implements Command {
-    constructor(private readonly args: Args) {}
+export class RunTask extends Command<Args> {
+    static readonly options = {
+        _: { description: '<taskName> [taskArgs...]' },
+    };
 
     @logErrors
     async execute() {
-        const taskName = this.args._[0];
+        const { _, taskName = this.args._[0], taskArgs = [], ...restOptions } = this.args;
 
         if (taskName in tasks) {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            const trimArgs = { ...this.args, _: this.args._.slice(1) };
-            await new tasks[taskName](trimArgs).execute();
+            await new tasks[taskName]({
+                _: [..._, ...taskArgs],
+                ...restOptions,
+            }).execute();
             return;
         }
 

package/src/cli/commands/start.ts

@@ -8,9 +8,9 @@ import {
     watchStdout,
     ProcessTree,
 } from '../utils';
-import { Command } from './types';
+import { Command, CommandArgs } from './types';
 
-interface Args {
+interface Args extends CommandArgs {
     'config'?: string;
     'code-coverage'?: boolean;
     'ignore'?: string | string[];
@@ -28,14 +28,16 @@ enum StartProcesses {
     BundlePackage,
 }
 
-export class Start implements Command {
-    readonly greedy = true;
-
-    constructor(private readonly args: Args) {}
-
-    description() {
-        return 'run project in development mode';
-    }
+export class Start extends Command<Args> {
+    static readonly description = 'Run project in development mode';
+    static readonly greedy = true;
+    static readonly options = {
+        'config': { string: true, hidden: true, description: 'Use specified configuration' },
+        'code-coverage': { boolean: true, description: 'Instrument code for coverage analysis?' },
+        'ignore': { array: true, description: 'Packages to skip' },
+        'scope': { array: true, description: 'Packages to run and watch' },
+        'use-tsc': { boolean: true, description: 'Use tsc to compile packages?' },
+    };
 
     @logErrors
     async execute() {

package/src/cli/commands/styles-check.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import { glob } from 'glob';
 import path from 'path';
 import { getFolders, isBundle, isLegacy, isStyleCheckDisabled, log, logErrors } from '../../utils';
-import { Command } from './index';
+import { Command } from './types';
 
 const patterns = [
     "@import '~@servicetitan/tokens/core/tokens.css';",
@@ -10,7 +10,7 @@ const patterns = [
     "@import '~@servicetitan/design-system/dist/system.min.css';",
 ];
 
-export class StylesCheck implements Command {
+export class StylesCheck extends Command {
     @logErrors
     async execute() {
         if (isLegacy() || !isBundle()) {

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

@@ -23,7 +23,7 @@ describe(`[startup] ${Tests.name}`, () => {
     const subject = async () => new Tests(args).execute();
 
     test('command is greedy', () => {
-        expect(new Tests(args).greedy).toBe(true);
+        expect(Tests.greedy).toBe(true);
     });
 
     function itRunsJest() {