@servicetitan/startup 35.2.0-far-1776.0 → 35.2.0

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

@@ -2,6 +2,7 @@ import { fs, vol } from 'memfs';
 import { exec, ExecException, execSync } from 'node:child_process';
 import { log } from '../../../utils';
 import { Clean } from '../clean';
+import { entry } from '../registry/clean';
 
 jest.mock('node:fs', () => fs);
 jest.mock('node:child_process', () => ({
@@ -41,7 +42,7 @@ describe(`[startup] ${Clean.name}`, () => {
     const subject = async () => new Clean({}).execute();
 
     test('allows running from global location', () => {
-        expect(Clean.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     function itLogsError(expectedMessage: string) {

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

@@ -1,6 +1,7 @@
 import { fs, vol } from 'memfs';
 import { prettify } from '../../../utils';
 import { ConvertEslintConfig } from '../convert-eslint-config';
+import { entry } from '../registry/convert-eslint-config';
 
 jest.mock('fs', () => fs);
 jest.mock('../../../utils', () => ({
@@ -41,7 +42,7 @@ describe(`[startup] ${ConvertEslintConfig.name}`, () => {
     }
 
     test('allows running from global location', () => {
-        expect(ConvertEslintConfig.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     describe(`when ${eslintrcFile} does not exist`, () => {

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

@@ -2,13 +2,15 @@ import { gitCloneRepo, gitIsReachable } from '@servicetitan/install';
 import fs from 'fs';
 import { vol } from 'memfs';
 import path from 'path';
-import { log } from '../../../utils';
 import { Init } from '../init';
+import { entry } from '../registry/init';
 
 jest.mock('@servicetitan/install');
 jest.mock('fs', () => require('memfs').fs);
 jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     log: { debug: jest.fn(), error: jest.fn(), info: jest.fn() },
+    logErrors: () => {},
 }));
 
 describe(`[startup] ${Init.name}`, () => {
@@ -20,13 +22,12 @@ describe(`[startup] ${Init.name}`, () => {
         jest.mocked(gitCloneRepo).mockReturnValue(true);
         jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
         jest.spyOn(fs, 'rmSync').mockImplementation(jest.fn());
-        jest.spyOn(log, 'error').mockImplementation(jest.fn()); // suppress error output
     });
 
     const subject = async () => new Init(args).execute();
 
     test('allows running from global location', () => {
-        expect(Init.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     test('clones "frontend-example" to current directory', async () => {

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

@@ -1,6 +1,7 @@
 import { execSync } from 'child_process';
 import { getStartupVersion, log } from '../../../utils';
 import { Install } from '../install';
+import { entry } from '../registry/install';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
 jest.mock('../../../utils', () => ({
@@ -22,7 +23,7 @@ describe(`${Install.name}`, () => {
     const subject = async () => new Install(args).execute();
 
     test('allows running from global location', () => {
-        expect(Install.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     test('runs install', async () => {

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

@@ -1,7 +1,8 @@
 import execa from 'execa';
 import { log } from '../../../utils';
 import { isModuleInstalled } from '../../utils';
-import { KendoUILicense, kendoUILicense } from '../kendo-ui-license';
+import { kendoUILicense } from '../kendo-ui-license';
+import { entry } from '../registry/kendo-ui-license';
 
 jest.mock('execa', () => jest.fn());
 
@@ -24,7 +25,7 @@ describe(`${kendoUILicense.name}`, () => {
     const subject = async () => kendoUILicense();
 
     test('allows running from global location', () => {
-        expect(KendoUILicense.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     test('activates license', async () => {

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

@@ -2,12 +2,14 @@ import { getPackages } from '../../../utils';
 import { eslint, lernaExec } from '../../utils';
 import { stylelint } from '../../utils/stylelint';
 import { Lint } from '../lint';
+import { entry } from '../registry/lint';
 
 jest.mock('stylelint', () => ({ lint: jest.fn() }));
 
 jest.mock('../../utils');
 jest.mock('../../utils/stylelint');
 jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     log: { debug: jest.fn(), info: jest.fn() },
     getConfiguration: jest.fn(() => ({})),
     getDestinationFolders: jest.fn(() => []),
@@ -69,7 +71,7 @@ describe(`[startup] ${Lint.name}`, () => {
     });
 
     test('command is greedy', () => {
-        expect(Lint.greedy).toBe(true);
+        expect(entry.greedy).toBe(true);
     });
 
     test('runs eslint directly', async () => {

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

@@ -2,6 +2,7 @@ import { fs, vol } from 'memfs';
 import path from 'node:path';
 import * as utils from '../../../utils';
 import { MfeCheck } from '../mfe-check';
+import { entry } from '../registry/mfe-check';
 
 jest.mock('fs', () => fs);
 jest.mock('../../../utils', () => ({
@@ -77,7 +78,7 @@ describe(`[startup] ${MfeCheck.name}`, () => {
     }
 
     test('allows running from global location', () => {
-        expect(MfeCheck.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     describe('when compatible', () => {

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

@@ -4,6 +4,7 @@ import { getPackageData, getStartupVersion, loadSharedDependencies, log } from '
 import { getLaunchDarklySdkVersion } from '../../../webpack/configs/utils/get-launchdarkly-sdk-version';
 import { getWebComponentsVersion } from '../../../webpack/configs/utils/get-web-components-version';
 import { MfeGenerateMetadata } from '../mfe-generate-metadata';
+import { entry } from '../registry/mfe-generate-metadata';
 
 jest.mock('fs', () => fs);
 jest.mock('../../../utils', () => ({
@@ -35,7 +36,6 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
 
     const mockParentPackageJson = {
         name: 'parent-package',
-        workspaces: ['packages/*'],
         dependencies: { 'some-dep': '^1.0.0' },
     };
 
@@ -77,7 +77,7 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
     const subject = () => new MfeGenerateMetadata({ ...mfeGenerateMetadataArgs }).execute();
 
     test('allows running from global location', () => {
-        expect(MfeGenerateMetadata.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     test('outputs valid JSON metadata', async () => {
@@ -110,28 +110,10 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
             });
         });
 
-        test('does not throw error', async () => {
-            await expect(subject()).resolves.not.toThrow();
-        });
-    });
-
-    describe('when tsconfig.json does not exist', () => {
-        beforeEach(() => {
-            vol.reset();
-            vol.fromJSON({
-                './package.json': JSON.stringify(mockPackageJson),
-                '../../package.json': JSON.stringify(mockParentPackageJson),
-            });
-        });
-
-        test('does not throw error', async () => {
-            await expect(subject()).resolves.not.toThrow();
-        });
-
-        test('outputs metadata with empty entrypoints', async () => {
-            await subject();
-
-            expect(getMetadataFromStdout().entrypoints).toEqual({});
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(
+                'this command must be run inside a web-component directory'
+            );
         });
     });
 

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

@@ -6,6 +6,7 @@ import { createInterface } from 'readline/promises';
 import { formatRelativeDate, toArray } from '../../../utils';
 import { isTTY, npmView, runCommand } from '../../utils';
 import { MFEList } from '../mfe-list';
+import { entry } from '../registry/mfe-list';
 
 jest.mock('@servicetitan/install');
 jest.mock('cli-table3');
@@ -152,7 +153,7 @@ describe(`[startup] ${MFEList.name}`, () => {
     }
 
     test('allows running from global location', () => {
-        expect(MFEList.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     test(`outputs table with last ${DEFAULT_LIMIT} published versions`, async () => {

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

@@ -2,10 +2,11 @@ import { fs, vol } from 'memfs';
 import { createPackage } from '../../../__mocks__';
 import { Package, PackageType, getPackages } from '../../../utils';
 import { lernaExec } from '../../utils';
-import { MFEPackageClean } from '../mfe-package-clean';
-import { MFEPackagePublish } from '../mfe-package-publish';
-import { MFEPackageRollback } from '../mfe-package-rollback';
 import { MFEPublish } from '../mfe-publish';
+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 { entry as mfePublish } from '../registry/mfe-publish';
 
 jest.mock('fs', () => fs);
 
@@ -260,25 +261,25 @@ describe(`[startup] ${MFEPublish.name}`, () => {
     });
 
     describe('options', () => {
-        const subject = () => MFEPublish.options;
+        const subject = () => mfePublish.options;
 
         test('groups publish, clean, and rollback options', () => {
             expect(subject()).toEqual(
                 expect.objectContaining({
                     ...Object.fromEntries(
-                        Object.entries(MFEPackagePublish.options).map(([key, value]) => [
+                        Object.entries(mfePackagePublish.options).map(([key, value]) => [
                             key,
                             { group: 'Publish Options:', ...value },
                         ])
                     ),
                     ...Object.fromEntries(
-                        Object.entries(MFEPackageClean.options).map(([key, value]) => [
+                        Object.entries(mfePackageClean.options).map(([key, value]) => [
                             `${key}\u00A0`,
                             { group: 'Clean Options:', ...value },
                         ])
                     ),
                     ...Object.fromEntries(
-                        Object.entries(MFEPackageRollback.options)
+                        Object.entries(mfePackageRollback.options)
                             .filter(([key]) => key !== 'scope')
                             .map(([key, value]) => {
                                 const optionProps = Object.fromEntries(

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

@@ -1,6 +1,7 @@
 import { createPackage } from '../../../__mocks__';
 import { Package, PackageType, getPackages, log } from '../../../utils';
 import { compile, lernaExec, typeCheck, watchStdout } from '../../utils';
+import { entry } from '../registry/start';
 import { Start } from '../start';
 
 jest.mock('../../../utils', () => ({
@@ -101,7 +102,7 @@ describe(`[startup] ${Start.name}`, () => {
     }
 
     test('command is greedy', () => {
-        expect(Start.greedy).toBe(true);
+        expect(entry.greedy).toBe(true);
     });
 
     describe('with TSC package', () => {

package/src/cli/commands/build.ts

@@ -1,17 +1,8 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
 import { checkArgs, compile, lernaExec, ProcessTree, typeCheck } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
-import { Command, CommandOptions } from './types';
-
-const 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 CommandOptions;
+import type { entry } from './registry/build';
+import { Command } from './types';
 
 enum BuildProcesses {
     Precompile,
@@ -23,11 +14,7 @@ enum BuildProcesses {
     BundlePackage,
 }
 
-export class Build extends Command<typeof options> {
-    static readonly description = 'Build project for production';
-    static readonly greedy = true;
-    static readonly options = options;
-
+export class Build extends Command<typeof entry> {
     @logErrors
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });

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

@@ -1,18 +1,9 @@
 import { getTsConfig, log, logErrors } from '../../utils';
 import { bundle, getModuleType } from '../utils';
-import { Command, CommandOptions } from './types';
+import type { entry } from './registry/bundle-package';
+import { Command } from './types';
 
-const 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 CommandOptions;
-
-export class BundlePackage extends Command<typeof options> {
-    static readonly options = options;
+export class BundlePackage extends Command<typeof entry> {
     @logErrors
     async execute() {
         const {

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

@@ -4,35 +4,25 @@ import {
     getFolders,
     getPackageData,
     getPackageName,
+    isWebComponent,
     loadSharedDependencies,
     log,
     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()) {
+            throw new Error('this command must be run inside a web-component directory');
+        }
+
         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();