@servicetitan/startup 32.1.0 → 32.3.0

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

@@ -0,0 +1,394 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { fs, vol } from 'memfs';
+import { createInterface } from 'readline/promises';
+import { formatRelativeDate, toArray } from '../../../utils';
+import { isTTY, npmView, npmWhoAmI, runCommand } from '../../utils';
+import { MFEList } from '../mfe-list';
+
+jest.mock('cli-table3');
+jest.mock('fs', () => fs);
+jest.mock('readline/promises', () => ({
+    createInterface: jest.fn(),
+}));
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    isTTY: jest.fn(),
+    npmView: jest.fn(),
+    npmWhoAmI: jest.fn(),
+    runCommand: jest.fn(),
+}));
+
+describe(`[startup] ${MFEList.name}`, () => {
+    const DEFAULT_LIMIT = 20;
+    const TOTAL_VERSIONS = DEFAULT_LIMIT + 1;
+    const mfeName = 'foo';
+    let distTags: Record<string, string>;
+    let time: Record<string, string>;
+    let args: ConstructorParameters<typeof MFEList>[0];
+
+    function volFromJSON(overrides: Record<string, any> = {}) {
+        vol.fromJSON({
+            'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
+            'packages/lib/package.json': JSON.stringify({ name: 'lib' }),
+            'packages/mfe/package.json': JSON.stringify({
+                name: mfeName,
+                cli: { 'web-component': true },
+            }),
+            ...overrides,
+        });
+    }
+
+    beforeEach(() => {
+        const versions = Array.from(new Array(TOTAL_VERSIONS), makeVersion);
+        time = versions.reduce<Record<string, string>>((result, version, index) => {
+            result[version] = hourAgo(index + 1).toISOString();
+            return result;
+        }, {});
+        distTags = {
+            dev: versions[0],
+            other: versions[0], // version with multiple tags
+            qa: versions[5],
+            stage: versions[10],
+            prod: versions[15],
+            latest: versions[DEFAULT_LIMIT],
+        };
+        args = { _: [] }; // eslint-disable-line @typescript-eslint/naming-convention
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress output
+        jest.mocked(npmWhoAmI).mockReturnValue('Foo');
+        jest.mocked(npmView).mockImplementation(({ packageName }) => ({
+            'name': packageName,
+            'version': distTags?.latest,
+            'dist-tags': distTags,
+            'time': {
+                created: hourAgo(24).toDateString(),
+                modified: new Date().toISOString(),
+                ...time,
+            },
+        }));
+        volFromJSON();
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => new MFEList(args).execute();
+
+    function hourAgo(count: number) {
+        const date = new Date();
+        date.setHours(date.getHours() - count);
+        return date;
+    }
+
+    function makeVersion() {
+        const hash = Math.floor(Math.random() * 1e8).toString(16);
+        return `0.0.0-master.${hash}`;
+    }
+
+    interface ExpectTableInfo {
+        name: string;
+        tags: Record<string, string>;
+        versions: [string, string][];
+    }
+
+    function expectCaption({
+        name,
+        version,
+        total,
+    }: {
+        name: string;
+        version?: string;
+        total: number;
+    }) {
+        const caption = [
+            chalk.bold.cyan(name),
+            version && `version: ${version}`,
+            `versions: ${total}`,
+        ]
+            .filter(el => !!el)
+            .join(' | ');
+
+        expect(jest.mocked(process.stdout.write)).toHaveBeenCalledWith(caption + '\n');
+    }
+
+    function expectTable(info: ExpectTableInfo | ExpectTableInfo[]) {
+        if (Array.isArray(info) && info.length === 0) {
+            expect(jest.mocked(Table).mock.instances).toHaveLength(0);
+            return;
+        }
+
+        toArray(info).forEach(({ name, tags, versions }, index) => {
+            const table = jest.mocked(Table).mock.instances[index];
+            const pushes = jest.mocked(table.push).mock.calls.map((...args) => args[0][0]);
+
+            const versionTags = Object.entries(tags).reduce<Record<string, string[]>>(
+                (result, [tag, version]) => {
+                    result[version] = [...(result[version] ?? []), tag];
+                    return result;
+                },
+                {}
+            );
+
+            expectCaption({ name, version: tags.latest, total: TOTAL_VERSIONS });
+
+            expect(pushes).toEqual([
+                ...versions.map(([version, when]) => [
+                    version,
+                    versionTags[version] ? chalk.bold.cyan(versionTags[version].join(', ')) : '',
+                    formatRelativeDate(when),
+                ]),
+            ]);
+        });
+    }
+
+    function itOmitsTable() {
+        test('omits table', async () => {
+            await subject();
+
+            expectTable([]);
+        });
+    }
+
+    test(`outputs table with last ${DEFAULT_LIMIT} published versions`, async () => {
+        await subject();
+
+        expect(Table).toHaveBeenCalledWith({
+            head: ['Version', 'Tag', 'When'].map(title => chalk.bold.cyan(title)),
+            style: { head: [] },
+        });
+
+        expectTable({
+            name: mfeName,
+            tags: distTags,
+            versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+        });
+    });
+
+    describe('when MFE has no versions', () => {
+        beforeEach(() => {
+            jest.mocked(npmView).mockImplementation(
+                ({ packageName }) => ({ name: packageName }) as any
+            );
+        });
+
+        itOmitsTable();
+    });
+
+    describe('when MFE has no "latest" tag', () => {
+        beforeEach(() => delete distTags.latest);
+
+        test('outputs table', async () => {
+            await subject();
+
+            expectTable({
+                name: mfeName,
+                tags: distTags,
+                versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+            });
+        });
+    });
+
+    describe('with --tagged', () => {
+        beforeEach(() => (args.tagged = true));
+
+        test('outputs only tagged versions', async () => {
+            await subject();
+
+            expectTable({
+                name: mfeName,
+                tags: distTags,
+                versions: [...new Set(Object.values(distTags))].map(version => [
+                    version,
+                    time[version],
+                ]),
+            });
+        });
+
+        describe('when MFE has no tags', () => {
+            beforeEach(() => ((distTags as any) = undefined));
+
+            itOmitsTable();
+        });
+    });
+
+    describe('with --registry', () => {
+        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+        test('passes registry to npmView', async () => {
+            await subject();
+
+            expect(npmView).toHaveBeenCalledWith({
+                packageName: mfeName,
+                registry: args.registry,
+            });
+        });
+    });
+
+    describe('with --all', () => {
+        beforeEach(() => (args.all = true));
+
+        test('outputs all published versions', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time),
+                },
+            ]);
+        });
+    });
+
+    describe('with --limit', () => {
+        beforeEach(() => (args.limit = 5));
+
+        test('outputs specified number of versions', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, args.limit),
+                },
+            ]);
+        });
+    });
+
+    describe('when workspace has no MFEs', () => {
+        beforeEach(() => vol.reset());
+
+        itOmitsTable();
+    });
+
+    describe('when workspace has multiple MFEs', () => {
+        const otherMfeName = `${mfeName}2`; // ensure sorts after first name
+
+        beforeEach(() => {
+            volFromJSON({
+                'packages/mfe2/package.json': JSON.stringify({
+                    name: otherMfeName,
+                    cli: { 'web-component': true },
+                }),
+            });
+        });
+
+        test('outputs published versions for all MFEs', async () => {
+            await subject();
+
+            expectTable([
+                {
+                    name: mfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                },
+                {
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                },
+            ]);
+        });
+
+        describe('with MFE name', () => {
+            beforeEach(() => (args._ = [otherMfeName]));
+
+            test('outputs only specified MFE', async () => {
+                await subject();
+
+                expectTable({
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                });
+            });
+        });
+
+        describe('with --ignore', () => {
+            beforeEach(() => (args.ignore = mfeName));
+
+            test('omits specified MFE', async () => {
+                await subject();
+
+                expectTable({
+                    name: otherMfeName,
+                    tags: distTags,
+                    versions: Object.entries(time).slice(0, DEFAULT_LIMIT),
+                });
+            });
+        });
+
+        describe('with non-existent MFE name', () => {
+            beforeEach(() => {
+                jest.mocked(npmView).mockReturnValue(undefined);
+            });
+
+            itOmitsTable();
+        });
+    });
+
+    describe('when machine is not authorized', () => {
+        const readline = { question: jest.fn(), close: jest.fn() };
+        let answer: string;
+
+        beforeEach(() => {
+            answer = 'Y';
+            jest.mocked(readline.question).mockImplementation(() => Promise.resolve(answer));
+            jest.mocked(createInterface).mockReturnValue(readline as any);
+            jest.mocked(npmWhoAmI).mockReturnValue(undefined);
+            jest.mocked(isTTY).mockReturnValue(true);
+        });
+
+        test('prompts and authorizes machine', async () => {
+            await subject();
+
+            expect(readline.question).toHaveBeenCalledWith(
+                expect.stringMatching(/machine is not authorized.*Authorize\? \[Y\/n\]/)
+            );
+            expect(readline.close).toHaveBeenCalled();
+            expect(runCommand).toHaveBeenCalledWith(
+                'npx --yes verdaccio-okta-oauth@latest --registry=https://verdaccio.servicetitan.com',
+                { quiet: true }
+            );
+        });
+
+        describe('when user does not answer', () => {
+            beforeEach(() => (answer = ''));
+
+            test('authorizes machine', async () => {
+                await subject();
+
+                expect(runCommand).toHaveBeenCalled();
+            });
+        });
+
+        describe('when user declines', () => {
+            beforeEach(() => (answer = 'n'));
+
+            test('throws error', async () => {
+                await expect(subject()).rejects.toThrow(/Not authorized/);
+            });
+        });
+
+        describe('when terminal is not interactive', () => {
+            beforeEach(() => jest.mocked(isTTY).mockReturnValue(false));
+
+            test('skips prompt and throws error', async () => {
+                await expect(subject()).rejects.toThrow(/machine is not authorized/);
+
+                expect(readline.question).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('with --registry', () => {
+            beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+            test('skips check whether machine is authorized', async () => {
+                await subject();
+
+                expect(npmWhoAmI).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

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