@servicetitan/startup 35.2.0-far-1776.1 → 35.2.0

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

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

@@ -0,0 +1,46 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        branch: {
+            string: true,
+            description: 'Branch name to associate with published version',
+            defaultDescription: 'current git branch',
+        },
+        build: {
+            string: true,
+            description: 'Package version',
+            defaultDescription: '<branch_name>.<commit_hash>',
+        },
+        dry: {
+            boolean: true,
+            description: 'Take no action and only log what would be published',
+        },
+        force: {
+            boolean: true,
+            description: 'Force publishing from an unrecognized branch',
+        },
+        registry: { string: true, hidden: true, description: 'Registry url' },
+        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 CommandEntry);

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

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

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

@@ -0,0 +1,55 @@
+import type { CommandEntry, CommandOptions } from '../types';
+import { defineEntry } from './define-entry';
+import { entry as mfePackageClean } from './mfe-package-clean';
+import { entry as mfePackagePublish } from './mfe-package-publish';
+import { entry as mfePackageRollback } from './mfe-package-rollback';
+
+function publishOptions() {
+    return Object.entries(mfePackagePublish.options).reduce((result, [key, value]) => {
+        result[key] = { group: 'Publish Options:', ...value };
+        return result;
+    }, {} as CommandOptions);
+}
+
+function cleanOptions() {
+    // no-break space suffix prevents key collisions
+    return Object.entries(mfePackageClean.options).reduce((result, [key, value]) => {
+        result[`${key}\u00A0`] = { group: 'Clean Options:', ...value };
+        return result;
+    }, {} as CommandOptions);
+}
+
+function rollbackOptions() {
+    // double no-break space suffix prevents key collisions
+    return Object.entries(mfePackageRollback.options).reduce((result, [key, value]) => {
+        const optionProps = Object.fromEntries(
+            Object.entries(value).filter(([k]) => k !== 'required')
+        );
+        result[`${key}\u00A0\u00A0`] = { group: 'Rollback Options:', ...optionProps };
+        return result;
+    }, {} as CommandOptions);
+}
+
+export const entry = defineEntry({
+    description: 'Publish or unpublish MFE packages',
+    options: {
+        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',
+        },
+        ...publishOptions(),
+        ...cleanOptions(),
+        ...rollbackOptions(),
+    },
+} satisfies CommandEntry);

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    allowRunFromGlobal: true,
+    description: 'Check project for configuration errors',
+    options: {
+        fix: { boolean: true, description: 'Fix detected problems' },
+        rule: { array: true, string: true, description: 'Limit checks to specified rule(s)' },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,14 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Run project in development mode',
+    greedy: true,
+    options: {
+        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 run and watch' },
+        useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/stylelint.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/styles-check.ts

@@ -0,0 +1,4 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({} satisfies CommandEntry);

package/src/cli/commands/registry/task.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: '<taskName> [taskArgs...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        taskName: { string: true, hidden: true },
+        taskArgs: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

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

@@ -0,0 +1,19 @@
+// NOTE: Not named test.ts to avoid being picked up by Jest as a test suite.
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    description: 'Run tests',
+    greedy: true,
+    options: {
+        /* eslint-disable @typescript-eslint/naming-convention */
+        _: { description: '[runnerArgs...]', array: true, string: true },
+        /* eslint-enable @typescript-eslint/naming-convention */
+        runner: {
+            choices: ['jest', 'vitest'] as const,
+            description: 'Test runner',
+            defaultDescription: 'jest',
+        },
+        runnerArgs: { array: true, string: true, hidden: true },
+    },
+} satisfies CommandEntry);

package/src/cli/commands/registry/upload-sourcemaps.ts

@@ -0,0 +1,14 @@
+import type { CommandEntry } from '../types';
+import { defineEntry } from './define-entry';
+
+export const entry = defineEntry({
+    options: {
+        dry: { boolean: true, description: 'Dry run mode' },
+        releaseVersion: {
+            string: true,
+            demandOption: true,
+            requiresArg: true,
+            description: 'Release version',
+        },
+    },
+} satisfies CommandEntry);

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

@@ -5,6 +5,7 @@ import path from 'path';
 import terminalLink from 'terminal-link';
 import type { ProjectPackage } from '../../../../utils';
 import { findPackages, getReviewConfiguration, log } from '../../../../utils';
+import { entry } from '../../registry/review';
 import { expectCalls } from '../__mocks__';
 import { Review } from '../review';
 import { rules } from '../rules';
@@ -61,7 +62,7 @@ describe(`[startup] ${Review.name}`, () => {
     }
 
     test('allows running from global location', () => {
-        expect(Review.allowRunFromGlobal).toBe(true);
+        expect(entry.allowRunFromGlobal).toBe(true);
     });
 
     describe('when not run from workspace root', () => {

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

@@ -9,7 +9,8 @@ import {
     readJsonSafe,
     toArray,
 } from '../../../utils';
-import { Command, CommandOptions } from '../types';
+import type { entry } from '../registry/review';
+import { Command } from '../types';
 import { rules } from './rules';
 import {
     ErrorSeverity,
@@ -32,16 +33,7 @@ import {
 
 const collator = new Intl.Collator();
 
-const options = {
-    fix: { boolean: true, description: 'Fix detected problems' },
-    rule: { array: true, string: true, description: 'Limit checks to specified rule(s)' },
-} satisfies CommandOptions;
-
-export class Review extends Command<typeof options> {
-    static readonly allowRunFromGlobal = true;
-    static readonly description = 'Check project for configuration errors';
-    static readonly options = options;
-
+export class Review extends Command<typeof entry> {
     private readonly severityToLabel: Record<ErrorSeverity, string> = {
         [ErrorSeverity.warning]: chalk.yellow('warning'),
         [ErrorSeverity.error]: chalk.red('error'),

package/src/cli/commands/review/rules/require-compatible-launch-darkly-sdk.ts

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
 import { satisfies } from 'semver';
-import { resolvePackageLockEntry } from '../../../../utils';
 import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
 import { applyFilter, checkPackages, setVersion } from '../utils';
 
@@ -122,7 +121,13 @@ export class RequireCompatibleLaunchDarklySdk implements PackageRule {
         dependency: string;
     }) {
         const { packages } = this.#project.packageLock;
-        return resolvePackageLockEntry(packages, dependency, packageName);
+        return (
+            (packageName
+                ? packages[`node_modules/${packageName}/node_modules/${dependency}`]
+                : undefined) ??
+            packages[`node_modules/${dependency}`] ??
+            {}
+        );
     }
 
     private getTargetJsClientSdkVersion(packageName?: string) {

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

@@ -1,5 +1,3 @@
-import { PackageLockPackages } from '../../../utils';
-
 export abstract class PackageRule {
     abstract get id(): string;
     abstract run(project: Project): PackageError | PackageError[] | undefined;
@@ -11,7 +9,14 @@ export interface Project {
     dependencies: Dependencies;
     // Only using this subset of package-lock.json
     packageLock: {
-        packages: PackageLockPackages;
+        packages: Record<
+            string,
+            {
+                version: string;
+                dependencies?: Record<string, string>;
+                peerDependencies?: Record<string, string>;
+            }
+        >;
         location: string;
     };
     packages: Package[];

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

@@ -2,13 +2,8 @@
 import { log, logErrors } from '../../utils';
 import { SwcCompilePackage, TscCompile, TscCompilePackage } from '../tasks';
 import { Task } from '../tasks/task';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    _: { description: '<taskName> [taskArgs...]', array: true, string: true },
-    taskName: { string: true, hidden: true },
-    taskArgs: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
+import type { entry } from './registry/task';
+import { Command } from './types';
 
 const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
     'tsc-compile-package': TscCompilePackage,
@@ -16,9 +11,7 @@ const tasks: Record<string, new (args: { [key: string]: unknown }) => Task> = {
     'tsc-compile': TscCompile,
 };
 
-export class RunTask extends Command<typeof options> {
-    static readonly options = options;
-
+export class RunTask extends Command<typeof entry> {
     @logErrors
     async execute() {
         const { _ = [], taskName = this.args._?.[0], taskArgs = [], ...restOptions } = this.args;

package/src/cli/commands/start.ts

@@ -8,15 +8,8 @@ import {
     typeCheck,
     watchStdout,
 } from '../utils';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    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 run and watch' },
-    useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-} satisfies CommandOptions;
+import type { entry } from './registry/start';
+import { Command } from './types';
 
 enum StartProcesses {
     Precompile,
@@ -29,11 +22,7 @@ enum StartProcesses {
     BundlePackage,
 }
 
-export class Start extends Command<typeof options> {
-    static readonly description = 'Run project in development mode';
-    static readonly greedy = true;
-    static readonly options = options;
-
+export class Start extends Command<typeof entry> {
     @logErrors
     async execute() {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });

package/src/cli/commands/stylelint.ts

@@ -1,17 +1,10 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { logErrors } from '../../utils';
 import { stylelint } from '../utils/stylelint';
-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 Stylelint extends Command<typeof options> {
-    static readonly options = options;
+import type { entry } from './registry/stylelint';
+import { Command } from './types';
 
+export class Stylelint extends Command<typeof entry> {
     @logErrors
     async execute() {
         await stylelint({ fix: this.args.fix, paths: this.paths });

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

@@ -2,6 +2,7 @@ import fs from 'fs';
 import { glob } from 'glob';
 import path from 'path';
 import { getFolders, isBundle, isLegacy, isStyleCheckDisabled, log, logErrors } from '../../utils';
+import type { entry } from './registry/styles-check';
 import { Command } from './types';
 
 const patterns = [
@@ -10,7 +11,7 @@ const patterns = [
     "@import '~@servicetitan/design-system/dist/system.min.css';",
 ];
 
-export class StylesCheck extends Command {
+export class StylesCheck extends Command<typeof entry> {
     @logErrors
     async execute() {
         if (isLegacy() || !isBundle()) {

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

@@ -1,4 +1,5 @@
 import { getConfiguration } from '../../../../utils';
+import { entry } from '../../registry/test-command';
 import { Jest, Vitest } from '../runners';
 import { Tests } from '../tests';
 
@@ -23,7 +24,7 @@ describe(`[startup] ${Tests.name}`, () => {
     const subject = async () => new Tests(args).execute();
 
     test('command is greedy', () => {
-        expect(Tests.greedy).toBe(true);
+        expect(entry.greedy).toBe(true);
     });
 
     function itRunsJest() {

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

@@ -1,28 +1,15 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { Config } from '@jest/types';
 import { getConfiguration, logErrors } from '../../../utils';
-import { Command, CommandOptions } from '../types';
+import type { entry } from '../registry/test-command';
+import { Command } from '../types';
 import { Jest, Vitest } from './runners';
 
-const options = {
-    _: { description: '[runnerArgs...]', array: true, string: true },
-    runner: {
-        choices: ['jest', 'vitest'] as const,
-        description: 'Test runner',
-        defaultDescription: 'jest',
-    },
-    runnerArgs: { array: true, string: true, hidden: true },
-} satisfies CommandOptions;
-
 /**
  * This class is named "Tests" instead of "Test" because the corresponding
  * "test.ts" would be interpreted as a test file.
  */
-export class Tests extends Command<typeof options, Config.Argv> {
-    static readonly description = 'Run tests';
-    static readonly greedy = true;
-    static readonly options = options;
-
+export class Tests extends Command<typeof entry, Config.Argv> {
     @logErrors
     async execute() {
         const {

package/src/cli/commands/types.ts

@@ -49,13 +49,15 @@ export type InferArgs<T extends CommandOptions, U = unknown> = Expand<
 > &
     U;
 
-export abstract class Command<T extends CommandOptions = CommandOptions, U = unknown> {
-    static readonly allowRunFromGlobal?: boolean;
-    static readonly description?: string;
-    static readonly greedy?: boolean;
-    static readonly options?: CommandOptions;
+export interface CommandEntry {
+    description?: string;
+    greedy?: boolean;
+    allowRunFromGlobal?: boolean;
+    options?: CommandOptions;
+}
 
-    constructor(protected readonly args: InferArgs<T, U>) {}
+export abstract class Command<T extends CommandEntry = CommandEntry, U = unknown> {
+    constructor(protected readonly args: InferArgs<NonNullable<T['options']>, U>) {}
 
     abstract execute(): Promise<void>;
 }

package/src/cli/commands/upload-sourcemaps.ts

@@ -3,24 +3,14 @@ import { execSync } from 'child_process';
 import path from 'path';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { TSConfig } from '../utils';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    dry: { boolean: true, description: 'Dry run mode' },
-    releaseVersion: {
-        string: true,
-        demandOption: true,
-        requiresArg: true,
-        description: 'Release version',
-    },
-} satisfies CommandOptions;
+import type { entry } from './registry/upload-sourcemaps';
+import { Command } from './types';
 
 interface PackageJson {
     name: string;
 }
 
-export class UploadSourcemaps extends Command<typeof options> {
-    static readonly options = options;
+export class UploadSourcemaps extends Command<typeof entry> {
     #outDir?: string;
     #packageJson?: PackageJson;