@servicetitan/startup 35.2.0-far-1776.1 → 35.3.0

package/src/cli/commands/clean.ts

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { log, logErrors } from '../../utils';
 import { ProcessTree } from '../utils/process-tree';
+import type { entry } from './registry/clean';
 import { Command } from './types';
 
 const exec = promisify(execAsync);
@@ -16,10 +17,7 @@ enum CleanProcesses {
     CleanGitWorkingTree,
 }
 
-export class Clean extends Command {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Reset project to fresh state';
-
+export class Clean extends Command<typeof entry> {
     @logErrors
     async execute() {
         const processTree = new ProcessTree<typeof CleanProcesses>();

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

@@ -2,6 +2,7 @@ import fs from 'fs';
 import { globSync } from 'glob';
 import JSON5 from 'json5';
 import { log, logErrors, prettify, toArray } from '../../utils';
+import type { entry } from './registry/convert-eslint-config';
 import { Command } from './types';
 
 const oldConfigFile = '.eslintrc.json';
@@ -38,10 +39,7 @@ interface Recipe {
     import: { as: string; from?: string };
 }
 
-export class ConvertEslintConfig extends Command {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Convert v8.x eslintrc.json to v9.x flat config';
-
+export class ConvertEslintConfig extends Command<typeof entry> {
     private static readonly recipes: Record<string, Recipe | null> = {
         '@servicetitan/eslint-config/mono': {
             import: { as: 'mono' },

package/src/cli/commands/eslint.ts

@@ -1,17 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { logErrors } from '../../utils';
 import { eslint } from '../utils';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    _: { description: '[paths...]', array: true, string: true },
-    fix: { boolean: true, hidden: true },
-    paths: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
-
-export class ESLintCommand extends Command<typeof options> {
-    static readonly options = options;
+import type { entry } from './registry/eslint';
+import { Command } from './types';
 
+export class ESLintCommand extends Command<typeof entry> {
     @logErrors
     async execute() {
         await eslint({ fix: this.args.fix, paths: this.paths });

package/src/cli/commands/init.ts

@@ -2,19 +2,12 @@ import { gitCloneRepo, gitIsReachable } from '@servicetitan/install';
 import fs from 'fs';
 import path from 'path';
 import { log, logErrors } from '../../utils';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    output: { string: true, description: 'Output path' },
-} satisfies CommandOptions;
+import type { entry } from './registry/init';
+import { Command } from './types';
 
 const REPO_NAME = 'frontend-example';
 
-export class Init extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Create example project';
-    static readonly options = options;
-
+export class Init extends Command<typeof entry> {
     @logErrors
     async execute() {
         const destination = path.resolve(this.args.output ?? '.');

package/src/cli/commands/install.ts

@@ -1,18 +1,9 @@
 import { execSync } from 'child_process';
 import { getStartupVersion, log, logErrors } from '../../utils';
-import { Command, CommandOptions } from './types';
-
-const 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 CommandOptions;
-
-export class Install extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Install project dependencies';
-    static readonly options = options;
+import type { entry } from './registry/install';
+import { Command } from './types';
 
+export class Install extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (!this.args.quiet) {

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

@@ -1,6 +1,7 @@
 import execa from 'execa';
 import { log, logErrors } from '../../utils';
 import { isModuleInstalled } from '../utils';
+import type { entry } from './registry/kendo-ui-license';
 import { Command } from './types';
 
 const ENCODED_LICENSE = `
@@ -28,10 +29,7 @@ const ENVIRONMENT_VARIABLE = 'KENDO_UI_LICENSE';
 const LICENSE = Buffer.from(ENCODED_LICENSE, 'base64').toString('ascii');
 const LICENSING_PACKAGE = '@progress/kendo-licensing';
 
-export class KendoUILicense extends Command {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Install KendoReact license key';
-
+export class KendoUILicense extends Command<typeof entry> {
     async execute() {
         if (!isModuleInstalled(LICENSING_PACKAGE)) {
             return;

package/src/cli/commands/lint.ts

@@ -2,22 +2,10 @@
 import { getPackages, log, logErrors } from '../../utils';
 import { eslint, lernaExec } from '../utils';
 import { stylelint } from '../utils/stylelint';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    _: { description: '[paths...]', array: true, string: true },
-    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 CommandOptions;
-
-export class Lint extends Command<typeof options> {
-    static readonly description = 'Run eslint and stylelint';
-    static readonly greedy = true;
-    static readonly options = options;
+import type { entry } from './registry/lint';
+import { Command } from './types';
 
+export class Lint extends Command<typeof entry> {
     async execute() {
         await this.checkStyles();
         await this.eslint();

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

@@ -10,7 +10,8 @@ import {
 } from '../../utils';
 import { Metadata } from '../../webpack/configs/types';
 import { getExposedDependencies } from '../../webpack/configs/utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/mfe-check';
+import { Command } from './types';
 
 interface HostPackageJSON {
     name: string;
@@ -33,33 +34,7 @@ interface CompatibilityResult {
     isHostMfe: boolean;
 }
 
-const 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 CommandOptions;
-
-export class MfeCheck extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Check MFE/host dependency compatibility';
-    static readonly options = options;
-
+export class MfeCheck extends Command<typeof entry> {
     @logErrors
     async execute() {
         const { metadata: metadataPath, hostPackageJson, json } = this.args;

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

@@ -10,20 +10,10 @@ import {
     logErrors,
 } from '../../utils';
 import { buildMetadata } from '../../webpack/configs/utils/build-metadata';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    output: {
-        description: 'Output file path (outputs to stdout if not specified)',
-        string: true,
-    },
-} satisfies CommandOptions;
-
-export class MfeGenerateMetadata extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Generate MFE metadata for compatibility checking';
-    static readonly options = options;
+import type { entry } from './registry/mfe-generate-metadata';
+import { Command } from './types';
 
+export class MfeGenerateMetadata extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (!isWebComponent()) {
@@ -32,12 +22,7 @@ export class MfeGenerateMetadata extends Command<typeof options> {
 
         const { output } = this.args;
 
-        let destination: string;
-        try {
-            ({ destination } = getFolders());
-        } catch {
-            destination = 'dist';
-        }
+        const { destination } = getFolders();
         const name = getPackageName();
         const packageData = getPackageData();
         const sharedDependencies = loadSharedDependencies(

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

@@ -12,33 +12,13 @@ import {
     PackageType,
 } from '../../utils';
 import { isTTY, NPMPackageInfo, npmView, runCommand } from '../utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/mfe-list';
+import { Command } from './types';
 import { DEFAULT_MFE_REGISTRY } from './utils';
 
-const options = {
-    _: { description: '[packageNames...]', array: true, string: true },
-    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 CommandOptions;
-
 const collator = new Intl.Collator();
 
-export class MFEList extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'List published MFE packages';
-    static readonly options = options;
-
+export class MFEList extends Command<typeof entry> {
     @logErrors
     async execute() {
         await this.login();

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);