@servicetitan/startup 35.2.0-far-1776.0 → 35.2.0

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

@@ -1,34 +1,10 @@
 import { getBranchesConfigs, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/mfe-package-clean';
+import { Command } from './types';
 import { DEFAULT_MFE_REGISTRY } from './utils';
 
-export const mfePackageCleanOptions = {
-    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' },
-} satisfies CommandOptions;
-
-export class MFEPackageClean extends Command<typeof mfePackageCleanOptions> {
-    static readonly options = mfePackageCleanOptions;
-
+export class MFEPackageClean extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (!isWebComponent()) {

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

@@ -21,51 +21,10 @@ import {
     npmView,
     runCommand,
 } from '../utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/mfe-package-publish';
+import { Command } from './types';
 import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } 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',
-    },
-    purgeCache: {
-        boolean: true,
-        description: 'Purge unpkg cache after publishing?',
-        defaultDescription: 'true',
-    },
-} satisfies CommandOptions;
-
 interface PublishData {
     buildVersion: string;
     dry: boolean;
@@ -85,9 +44,7 @@ interface PackageJson {
     files?: string[];
 }
 
-export class MFEPackagePublish extends Command<typeof mfePackagePublishOptions> {
-    static readonly options = mfePackagePublishOptions;
-
+export class MFEPackagePublish extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (this.args.dry) {

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

@@ -1,37 +1,14 @@
 import { log, logErrors, readJson } from '../../utils';
 import { DRY_RUN_PREFIX, npmTagVersion, npmView } from '../utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/mfe-package-rollback';
+import { Command } from './types';
 import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } 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,
-    },
-    purgeCache: {
-        boolean: true,
-        description: 'Purge unpkg cache after rolling back?',
-        defaultDescription: 'true',
-    },
-} satisfies CommandOptions;
-
 interface PackageJson {
     name: string;
 }
 
-export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions> {
-    static readonly options = mfePackageRollbackOptions;
-
+export class MFEPackageRollback extends Command<typeof entry> {
     private get dryRunPrefix() {
         return this.args.dry ? DRY_RUN_PREFIX : '';
     }

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

@@ -1,82 +1,20 @@
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
 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';
+import { entry as mfePackageClean } from './registry/mfe-package-clean';
+import { entry as mfePackagePublish } from './registry/mfe-package-publish';
+import { entry as mfePackageRollback } from './registry/mfe-package-rollback';
+import type { entry } from './registry/mfe-publish';
+import { Command } from './types';
 
-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 &
+type MFEPublishOptions = (typeof entry)['options'] &
+    (typeof mfePackagePublish)['options'] &
+    (typeof mfePackageClean)['options'] &
     // 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'>;
+    Omit<(typeof mfePackageRollback)['options'], 'tag'> & {
+        tag: Omit<(typeof mfePackageRollback)['options']['tag'], 'required'>;
     };
 
-export class MFEPublish extends Command<MFEPublishOptions> {
-    static readonly description = 'Publish or unpublish MFE packages';
-    static get options() {
-        const publishOptions = Object.entries(mfePackagePublishOptions).reduce(
-            (result, [key, value]) => {
-                result[key] = { group: 'Publish Options:', ...value };
-                return result;
-            },
-            {} as NonNullable<typeof Command.options>
-        );
-
-        const cleanOptions = Object.entries(mfePackageCleanOptions).reduce(
-            (result, [key, value]) => {
-                // no-break space suffix prevents key collisions
-                result[`${key}\u00A0`] = {
-                    group: 'Clean Options:',
-                    ...value,
-                };
-                return result;
-            },
-            {} as NonNullable<typeof Command.options>
-        );
-
-        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,
-        };
-    }
-
+export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
     @logErrors
     async execute() {
         const packages = getPackages({ scope: this.args.scope, type: PackageType.Webpack }).filter(

package/src/cli/commands/mfe-purge-cache.ts

@@ -1,28 +1,6 @@
 import { log, logErrors } from '../../utils';
-import { Command, CommandOptions } from './types';
-
-const mfePurgeCacheOptions = {
-    host: {
-        string: true,
-        description: 'Host URL to send purge requests to',
-        demandOption: true,
-    },
-    packageName: {
-        string: true,
-        description: 'Package name to purge',
-        demandOption: true,
-    },
-    tag: {
-        string: true,
-        description: 'Package tag to purge',
-        demandOption: true,
-    },
-    token: {
-        string: true,
-        description: 'X-Purge-Token header value',
-        defaultDescription: 'process.env.UNPKG_PURGE_TOKEN',
-    },
-} satisfies CommandOptions;
+import type { entry } from './registry/mfe-purge-cache';
+import { Command } from './types';
 
 export type PurgeResponse = {
     pod: string;
@@ -31,9 +9,7 @@ export type PurgeResponse = {
     location: string | null;
 }[];
 
-export class MFEPurgeCache extends Command<typeof mfePurgeCacheOptions> {
-    static readonly options = mfePurgeCacheOptions;
-
+export class MFEPurgeCache extends Command<typeof entry> {
     @logErrors
     async execute() {
         const { host: rawHost, packageName, tag } = this.args;

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

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

package/src/cli/commands/registry/__tests__/command-registry.test.ts

@@ -0,0 +1,13 @@
+import { commandRegistry } from '../command-registry';
+
+jest.mock('stylelint', () => ({ lint: jest.fn() }));
+
+describe('[startup] commandRegistry', () => {
+    test.each(Object.entries(commandRegistry))(
+        '%s: load() resolves to a command class',
+        async (_, entry) => {
+            const CommandClass = await entry.load();
+            expect(typeof CommandClass).toBe('function');
+        }
+    );
+});

package/src/cli/commands/registry/build.ts

@@ -0,0 +1,16 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Build project for production',
+    greedy: true,
+    options: {
+        cdnPath: { string: true, description: 'Base url for application assets' },
+        codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
+        config: { string: true, hidden: true, description: 'Use specified configuration' },
+        ignore: { array: true, string: true, description: 'Packages to skip' },
+        scope: { array: true, string: true, description: 'Packages to build' },
+        stat: { boolean: true, description: 'Generate bundle report?' },
+        useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,13 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        codeCoverage: { boolean: true, hidden: true },
+        config: { string: true, hidden: true },
+        exposedDependencies: { boolean: true, hidden: true },
+        stat: { boolean: true, hidden: true },
+        useWatchConfig: { boolean: true, hidden: true },
+        watch: { boolean: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/clean.ts

@@ -0,0 +1,7 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Reset project to fresh state',
+} satisfies CommandEntry);

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

@@ -0,0 +1,98 @@
+import { CommandName } from '../../../utils';
+import { Command, CommandEntry, Newable } from '../types';
+import { entry as build } from './build';
+import { entry as bundlePackage } from './bundle-package';
+import { entry as clean } from './clean';
+import { entry as convertEslintConfig } from './convert-eslint-config';
+import { entry as eslint } from './eslint';
+import { entry as init } from './init';
+import { entry as install } from './install';
+import { entry as kendoUiLicense } from './kendo-ui-license';
+import { entry as lint } from './lint';
+import { entry as mfeCheck } from './mfe-check';
+import { entry as mfeGenerateMetadata } from './mfe-generate-metadata';
+import { entry as mfeList } from './mfe-list';
+import { entry as mfePackageClean } from './mfe-package-clean';
+import { entry as mfePackagePublish } from './mfe-package-publish';
+import { entry as mfePackageRollback } from './mfe-package-rollback';
+import { entry as mfePublish } from './mfe-publish';
+import { entry as mfePurgeCache } from './mfe-purge-cache';
+import { entry as preparePackage } from './prepare-package';
+import { entry as review } from './review';
+import { entry as start } from './start';
+import { entry as stylelint } from './stylelint';
+import { entry as stylesCheck } from './styles-check';
+import { entry as task } from './task';
+import { entry as test } from './test-command';
+import { entry as uploadSourcemaps } from './upload-sourcemaps';
+
+export interface CommandRegistryEntry extends CommandEntry {
+    load: () => Promise<Newable<Command>>;
+}
+
+function toPascalCase(name: string): string {
+    return name
+        .split('-')
+        .map(part => part[0].toUpperCase() + part.slice(1))
+        .join('');
+}
+
+interface MakeEntryOptions {
+    path?: string;
+    className?: string;
+}
+
+function makeEntry<K extends CommandName, T extends CommandEntry>(
+    key: K,
+    entry: T,
+    options: MakeEntryOptions = {}
+) {
+    const { path = key, className = toPascalCase(path) } = options;
+    return {
+        [key]: {
+            ...entry,
+            load: () => import(`../${path}`).then(m => m[className]),
+        },
+    } as { [k in K]: T & CommandRegistryEntry };
+}
+
+/*
+ * Each makeEntry call returns a single-key object. Spreading them preserves the
+ * per-command type information, as opposed to widening each value to the union
+ * return type.
+ */
+export const commandRegistry = {
+    ...makeEntry(CommandName.build, build),
+    ...makeEntry(CommandName['bundle-package'], bundlePackage),
+    ...makeEntry(CommandName.clean, clean),
+    ...makeEntry(CommandName['convert-eslint-config'], convertEslintConfig),
+    ...makeEntry(CommandName.eslint, eslint, { className: 'ESLintCommand' }),
+    ...makeEntry(CommandName.init, init),
+    ...makeEntry(CommandName.install, install),
+    ...makeEntry(CommandName['kendo-ui-license'], kendoUiLicense, { className: 'KendoUILicense' }),
+    ...makeEntry(CommandName.lint, lint),
+    ...makeEntry(CommandName['mfe-check'], mfeCheck),
+    ...makeEntry(CommandName['mfe-generate-metadata'], mfeGenerateMetadata),
+    ...makeEntry(CommandName['mfe-list'], mfeList, { className: 'MFEList' }),
+    ...makeEntry(CommandName['mfe-package-clean'], mfePackageClean, {
+        className: 'MFEPackageClean',
+    }),
+    ...makeEntry(CommandName['mfe-package-publish'], mfePackagePublish, {
+        className: 'MFEPackagePublish',
+    }),
+    ...makeEntry(CommandName['mfe-package-rollback'], mfePackageRollback, {
+        className: 'MFEPackageRollback',
+    }),
+    ...makeEntry(CommandName['mfe-publish'], mfePublish, { className: 'MFEPublish' }),
+    ...makeEntry(CommandName['mfe-purge-cache'], mfePurgeCache, {
+        className: 'MFEPurgeCache',
+    }),
+    ...makeEntry(CommandName['prepare-package'], preparePackage),
+    ...makeEntry(CommandName.review, review),
+    ...makeEntry(CommandName.start, start),
+    ...makeEntry(CommandName.stylelint, stylelint),
+    ...makeEntry(CommandName['styles-check'], stylesCheck),
+    ...makeEntry(CommandName.task, task, { path: 'run-task' }),
+    ...makeEntry(CommandName.test, test, { className: 'Tests' }),
+    ...makeEntry(CommandName['upload-sourcemaps'], uploadSourcemaps),
+} satisfies Record<CommandName, CommandRegistryEntry>;

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

@@ -0,0 +1,7 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Convert v8.x eslintrc.json to v9.x flat config',
+} satisfies CommandEntry);

package/src/cli/commands/registry/define-entry.ts

@@ -0,0 +1,11 @@
+import type { CommandEntry } from '../types';
+
+/**
+ * Use this instead of `satisfies CommandEntry` to get both excess property checking
+ * and narrow type inference.
+ */
+export function defineEntry<T extends CommandEntry>(
+    entry: T & Record<Exclude<keyof T, keyof CommandEntry>, never>
+): T {
+    return entry;
+}

package/src/cli/commands/registry/eslint.ts

@@ -0,0 +1,12 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[paths...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        fix: { boolean: true, hidden: true },
+        paths: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/index.ts

@@ -0,0 +1,2 @@
+export { commandRegistry } from './command-registry';
+export type { CommandRegistryEntry } from './command-registry';

package/src/cli/commands/registry/init.ts

@@ -0,0 +1,10 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Create example project',
+    allowRunFromGlobal: true,
+    options: {
+        output: { string: true, description: 'Output path' },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/install.ts

@@ -0,0 +1,12 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Install project dependencies',
+    options: {
+        fix: { boolean: true, description: 'Update and dedupe package-lock.json', hidden: true },
+        quiet: { boolean: true, description: 'Suppress output', hidden: true },
+        token: { boolean: true, description: 'Configure npm token' },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,7 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Install KendoReact license key',
+} satisfies CommandEntry);

package/src/cli/commands/registry/lint.ts

@@ -0,0 +1,17 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Run eslint and stylelint',
+    greedy: true,
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[paths...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        fix: { boolean: true, description: 'Apply fixes for issues?' },
+        scope: { array: true, string: true, hidden: true, description: 'Packages to lint' },
+        ignore: { array: true, string: true, hidden: true, description: 'Packages to skip' },
+        parallel: { boolean: true, hidden: true, description: 'Lint each package separately' },
+        paths: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/mfe-check.ts

@@ -0,0 +1,28 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Check MFE/host dependency compatibility',
+    options: {
+        metadata: {
+            description:
+                "Path to MFE's metadata.json file, can be generated with the 'mfe-generate-metadata' command",
+            string: true,
+            demandOption: true,
+            requiresArg: true,
+        },
+        hostPackageJson: {
+            description: 'Path(s) to host package.json files',
+            array: true,
+            string: true,
+            demandOption: true,
+            requiresArg: true,
+        },
+        json: {
+            description: 'Output results as JSON',
+            boolean: true,
+            default: false,
+        },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/mfe-generate-metadata.ts

@@ -0,0 +1,13 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Generate MFE metadata for compatibility checking',
+    options: {
+        output: {
+            description: 'Output file path (outputs to stdout if not specified)',
+            string: true,
+        },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,25 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'List published MFE packages',
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[packageNames...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        all: { boolean: true, description: 'List all published versions ' },
+        ignore: {
+            array: true,
+            string: true,
+            description: 'Exclude MFEs with names matching specified glob pattern ',
+        },
+        limit: {
+            number: true,
+            description: 'List only the specified number of published versions',
+        },
+        packageNames: { array: true, string: true, hidden: true },
+        registry: { string: true, hidden: true },
+        tagged: { boolean: true, description: 'List only tagged versions' },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,27 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    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' },
+    },
+} satisfies CommandEntry);