@servicetitan/startup 35.2.0-far-1776.1 → 35.3.0

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

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[];