@servicetitan/startup 33.1.1 → 34.0.0

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

@@ -1,9 +1,7 @@
-import execa from 'execa';
 import fs from 'fs';
 import { globSync } from 'glob';
 import JSON5 from 'json5';
-
-import { log, logErrors, toArray } from '../../utils';
+import { log, logErrors, prettify, toArray } from '../../utils';
 import { Command } from './types';
 
 const oldConfigFile = '.eslintrc.json';
@@ -41,6 +39,7 @@ interface Recipe {
 }
 
 export class ConvertEslintConfig extends Command {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'Convert v8.x eslintrc.json to v9.x flat config';
 
     private static readonly recipes: Record<string, Recipe | null> = {
@@ -91,7 +90,7 @@ export class ConvertEslintConfig extends Command {
 
         const json = this.readJson(oldConfigFile);
         fs.writeFileSync(newConfigFile, this.convert(json), 'utf-8');
-        await this.prettify(newConfigFile);
+        await prettify(newConfigFile);
 
         log.success(`Created ${newConfigFile}`);
     }
@@ -265,14 +264,6 @@ export class ConvertEslintConfig extends Command {
         flatConfigs.push(JSON.stringify({ settings }));
     }
 
-    private async prettify(filename: string) {
-        try {
-            await execa('npx', ['prettier', '-w', filename], { stdout: 'ignore' });
-        } catch (error: any) {
-            throw new Error(`prettier failed with exit code ${error.exitCode}`);
-        }
-    }
-
     private readJson(filename: string) {
         return JSON5.parse(fs.readFileSync(filename, 'utf8'));
     }

package/src/cli/commands/eslint.ts

@@ -1,18 +1,16 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { logErrors } from '../../utils';
 import { eslint } from '../utils';
-import { Command, CommandArgs } from './types';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    _: string[];
-    fix?: boolean;
-    paths?: string[];
-}
+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<Args> {
-    static readonly options = {
-        _: { description: '[paths...]' },
-    };
+export class ESLintCommand extends Command<typeof options> {
+    static readonly options = options;
 
     @logErrors
     async execute() {
@@ -20,7 +18,7 @@ export class ESLintCommand extends Command<Args> {
     }
 
     private get paths() {
-        const { _, paths = [] } = this.args;
+        const { _ = [], paths = [] } = this.args;
         return [..._, ...paths];
     }
 }

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

@@ -1,5 +1,4 @@
 import { CommandName } from '../../utils';
-
 import { Build } from './build';
 import { BundlePackage } from './bundle-package';
 import { Clean } from './clean';
@@ -9,9 +8,12 @@ import { Init } from './init';
 import { Install } from './install';
 import { KendoUILicense } from './kendo-ui-license';
 import { Lint } from './lint';
+import { MfeCheck } from './mfe-check';
+import { MfeGenerateMetadata } from './mfe-generate-metadata';
 import { MFEList } from './mfe-list';
 import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
+import { MFEPackageRollback } from './mfe-package-rollback';
 import { MFEPublish } from './mfe-publish';
 import { PreparePackage } from './prepare-package';
 import { Review } from './review';
@@ -33,9 +35,12 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName.install]: Install,
     [CommandName['kendo-ui-license']]: KendoUILicense,
     [CommandName.lint]: Lint,
+    [CommandName['mfe-check']]: MfeCheck,
+    [CommandName['mfe-generate-metadata']]: MfeGenerateMetadata,
     [CommandName['mfe-list']]: MFEList,
     [CommandName['mfe-package-clean']]: MFEPackageClean,
     [CommandName['mfe-package-publish']]: MFEPackagePublish,
+    [CommandName['mfe-package-rollback']]: MFEPackageRollback,
     [CommandName['mfe-publish']]: MFEPublish,
     [CommandName['prepare-package']]: PreparePackage,
     [CommandName.review]: Review,

package/src/cli/commands/index.ts

@@ -6,9 +6,9 @@ export * from './init';
 export * from './install';
 export * from './kendo-ui-license';
 export * from './lint';
+export * from './mfe-publish';
 export * from './prepare-package';
 export * from './start';
-export * from './test';
 export * from './styles-check';
-export * from './mfe-publish';
+export * from './test';
 export type * from './types';

package/src/cli/commands/init.ts

@@ -1,21 +1,19 @@
 import { gitCloneRepo, gitIsReachable } from '@servicetitan/install';
 import fs from 'fs';
 import path from 'path';
-
 import { log, logErrors } from '../../utils';
-import { Command, CommandArgs } from './types';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    output?: string;
-}
+const options = {
+    output: { string: true, description: 'Output path' },
+} satisfies CommandOptions;
 
 const REPO_NAME = 'frontend-example';
 
-export class Init extends Command<Args> {
+export class Init extends Command<typeof options> {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'Create example project';
-    static readonly options = {
-        output: { string: true, description: 'Output path' },
-    };
+    static readonly options = options;
 
     @logErrors
     async execute() {

package/src/cli/commands/install.ts

@@ -1,19 +1,17 @@
 import { execSync } from 'child_process';
-import { log, logErrors, getStartupVersion } from '../../utils';
-import { Command, CommandArgs } from './types';
-interface Args extends CommandArgs {
-    fix?: boolean;
-    quiet?: boolean;
-    token?: boolean;
-}
+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<Args> {
+export class Install extends Command<typeof options> {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'Install project dependencies';
-    static readonly options = {
-        fix: { boolean: true, describe: 'Update and dedupe package-lock.json', hidden: true },
-        quiet: { boolean: true, describe: 'Suppress output', hidden: true },
-        token: { boolean: true, describe: 'Configure npm token' },
-    };
+    static readonly options = options;
 
     @logErrors
     async execute() {

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

@@ -1,5 +1,4 @@
 import execa from 'execa';
-
 import { log, logErrors } from '../../utils';
 import { isModuleInstalled } from '../utils';
 import { Command } from './types';
@@ -30,6 +29,7 @@ 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';
 
     async execute() {

package/src/cli/commands/lint.ts

@@ -1,28 +1,22 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { getPackages, log, logErrors } from '../../utils';
-import { Command, CommandArgs } from './types';
 import { eslint, lernaExec } from '../utils';
 import { stylelint } from '../utils/stylelint';
+import { Command, CommandOptions } from './types';
 
-interface Args extends CommandArgs {
-    _: string[];
-    fix?: boolean;
-    scope?: string | string[];
-    ignore?: string | string[];
-    parallel?: boolean;
-    paths?: string[];
-}
+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<Args> {
+export class Lint extends Command<typeof options> {
     static readonly description = 'Run eslint and stylelint';
     static readonly greedy = true;
-    static readonly options = {
-        _: { description: '[paths...]' },
-        fix: { boolean: true, description: 'Apply fixes for issues?' },
-        scope: { array: true, hidden: true, description: 'Packages to lint' },
-        ignore: { array: true, hidden: true, description: 'Packages to skip' },
-        parallel: { boolean: true, hidden: true, description: 'Lint each package separately' },
-    };
+    static readonly options = options;
 
     async execute() {
         await this.checkStyles();
@@ -76,7 +70,7 @@ export class Lint extends Command<Args> {
     }
 
     private get paths() {
-        const { _, paths = [] } = this.args;
+        const { _ = [], paths = [] } = this.args;
         return [..._, ...paths];
     }
 }

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

@@ -0,0 +1,166 @@
+import { getVersionMismatches } from '@servicetitan/startup-utils';
+import path from 'node:path';
+import {
+    isWebComponent,
+    loadSharedDependencies,
+    log,
+    logErrors,
+    readJson,
+    toArray,
+} from '../../utils';
+import { Metadata } from '../../webpack/configs/types';
+import { getExposedDependencies } from '../../webpack/configs/utils';
+import { Command, CommandOptions } from './types';
+
+interface HostPackageJSON {
+    name: string;
+    dependencies: Record<string, string>;
+    cli?: {
+        'web-component'?: boolean | string | object;
+        'webpack'?: {
+            'expose-shared-dependencies'?: boolean;
+            'shared-dependencies'?: Record<string, string>;
+        };
+    };
+}
+
+interface CompatibilityResult {
+    name: string;
+    compatible: boolean;
+    bundleType: 'light' | 'full';
+    mismatches?: Record<string, { host: string; package: string }>;
+    isSharedDependenciesEnabled: boolean;
+    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;
+
+    @logErrors
+    async execute() {
+        const { metadata: metadataPath, hostPackageJson, json } = this.args;
+        const mfeMetadata = readJson<Metadata>(path.resolve(metadataPath));
+        const hostPackageJsonPaths = toArray(hostPackageJson);
+        const hostData = this.getHostPackageData(hostPackageJsonPaths);
+        const result = this.checkCompatibility(mfeMetadata, hostData);
+
+        if (json) {
+            this.outputJson(result);
+        } else {
+            this.outputHumanReadable(result);
+        }
+
+        if (!result.compatible) {
+            process.exitCode = 1;
+        }
+
+        return Promise.resolve();
+    }
+
+    private getHostPackageData(packageJsonPaths: string[]): HostPackageJSON {
+        const packages = packageJsonPaths.map(packageJsonPath =>
+            readJson<HostPackageJSON>(path.resolve(packageJsonPath))
+        );
+        const mergedDependencies = packages.reduceRight<HostPackageJSON['dependencies']>(
+            (result, currentPackage) => Object.assign(result, currentPackage.dependencies),
+            {}
+        );
+        const mainPackage = packages[0];
+
+        return {
+            name: mainPackage.name,
+            cli: mainPackage.cli,
+            dependencies: mergedDependencies,
+        };
+    }
+
+    private checkCompatibility(
+        mfeMetadata: Metadata,
+        hostData: HostPackageJSON
+    ): CompatibilityResult {
+        const mfeSharedDependencies = mfeMetadata.sharedDependencies;
+        const hostSharedDependencies = loadSharedDependencies(
+            hostData.dependencies,
+            hostData.cli?.webpack?.['shared-dependencies']
+        );
+        const exposedDependencies = getExposedDependencies(
+            hostSharedDependencies,
+            hostData.dependencies
+        );
+        const mismatchResult = getVersionMismatches(
+            exposedDependencies,
+            mfeMetadata.dependencies,
+            mfeSharedDependencies
+        );
+
+        const isHostMfe = isWebComponent(hostData);
+        const isSharedDependenciesEnabled =
+            hostData.cli?.webpack?.['expose-shared-dependencies'] === true;
+        const compatible = !isHostMfe && !mismatchResult && isSharedDependenciesEnabled;
+
+        return {
+            name: mfeMetadata.name,
+            compatible,
+            bundleType: compatible ? 'light' : 'full',
+            isSharedDependenciesEnabled,
+            isHostMfe,
+            ...(mismatchResult ? { mismatches: mismatchResult } : {}),
+        };
+    }
+
+    private outputJson(result: CompatibilityResult) {
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    }
+
+    private outputHumanReadable(result: CompatibilityResult) {
+        log.info(`Checking ${result.name}...`);
+
+        if (result.isHostMfe) {
+            log.error('Skipping compatibility check because host is an MFE');
+            return;
+        }
+
+        if (result.compatible) {
+            log.info('Compatible: light bundle can be used');
+            return;
+        }
+
+        if (result.mismatches) {
+            log.error('Dependency mismatch found:');
+
+            for (const [dep, versions] of Object.entries(result.mismatches)) {
+                log.error(`  ${dep}: host=${versions.host}, package=${versions.package}`);
+            }
+        }
+
+        if (!result.isSharedDependenciesEnabled) {
+            log.error('expose-shared-dependencies is not enabled in host package.json');
+        }
+
+        log.error('Result: full bundle required');
+    }
+}

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

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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;
+
+    @logErrors
+    async execute() {
+        if (!isWebComponent()) {
+            throw new Error('this command must be run inside a web-component directory');
+        }
+
+        const { output } = this.args;
+
+        const { destination } = getFolders();
+        const name = getPackageName();
+        const packageData = getPackageData();
+        const sharedDependencies = loadSharedDependencies(
+            packageData.dependencies,
+            packageData.sharedDependencies
+        );
+
+        const metadata = buildMetadata({
+            destination,
+            name,
+            version: packageData.version,
+            dependencies: packageData.dependencies,
+            sharedDependencies,
+        });
+
+        const jsonOutput = JSON.stringify(metadata, null, 2);
+
+        if (output) {
+            const outputPath = path.resolve(output);
+            const outputDir = path.dirname(outputPath);
+
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+
+            fs.writeFileSync(outputPath, jsonOutput, 'utf8');
+            log.info(`Metadata written to ${outputPath}`);
+        } else {
+            process.stdout.write(jsonOutput + '\n');
+        }
+
+        return Promise.resolve();
+    }
+}

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

@@ -11,38 +11,33 @@ import {
     logErrors,
     PackageType,
 } from '../../utils';
-import { Command, CommandArgs } from './types';
 import { isTTY, NPMPackageInfo, npmView, runCommand } from '../utils';
-
-interface Args extends CommandArgs {
-    _: string[];
-    all?: boolean;
-    ignore?: string | string[];
-    limit?: number;
-    packageNames?: string[];
-    registry?: string;
-    tagged?: boolean;
-}
+import { Command, CommandOptions } 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();
 
-const VERDACCIO = 'https://verdaccio.servicetitan.com';
-
-export class MFEList extends Command<Args> {
+export class MFEList extends Command<typeof options> {
+    static readonly allowRunFromGlobal = true;
     static readonly description = 'List published MFE packages';
-    static readonly options = {
-        _: { description: '[packageNames...]' },
-        all: { boolean: true, description: 'List all published versions ' },
-        ignore: {
-            array: true,
-            description: 'Exclude MFEs with names matching specified glob pattern ',
-        },
-        limit: {
-            number: true,
-            description: 'List only the specified number of published versions',
-        },
-        tagged: { boolean: true, description: 'List only tagged versions' },
-    };
+    static readonly options = options;
 
     @logErrors
     async execute() {
@@ -130,7 +125,10 @@ export class MFEList extends Command<Args> {
     }
 
     private async login() {
-        if (this.registry !== VERDACCIO || npmWhoAmI({ registry: this.registry }) !== undefined) {
+        if (
+            this.registry !== DEFAULT_MFE_REGISTRY ||
+            npmWhoAmI({ registry: this.registry }) !== undefined
+        ) {
             return;
         }
 
@@ -157,7 +155,7 @@ export class MFEList extends Command<Args> {
     }
 
     private get packageNames() {
-        const { _, packageNames = [] } = this.args;
+        const { _ = [], packageNames = [] } = this.args;
         if (_.length || packageNames.length) {
             return [..._, ...packageNames];
         }
@@ -169,6 +167,6 @@ export class MFEList extends Command<Args> {
     }
 
     private get registry() {
-        return this.args.registry ?? VERDACCIO;
+        return this.args.registry ?? DEFAULT_MFE_REGISTRY;
     }
 }

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

@@ -1,38 +1,33 @@
 import { getBranchesConfigs, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../utils';
-import { Command, CommandArgs } from './types';
-
-export interface Args extends CommandArgs {
-    all?: true;
-    branch?: string;
-    count?: number;
-    dry?: boolean;
-    registry?: string;
-}
-
-export class MFEPackageClean extends Command<Args> {
-    static readonly 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' },
-    };
+import { Command, CommandOptions } 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;
 
     @logErrors
     async execute() {
@@ -109,7 +104,7 @@ export class MFEPackageClean extends Command<Args> {
             branches = [gitGetBranch()];
         }
 
-        const registry = this.args.registry ?? 'https://verdaccio.servicetitan.com';
+        const registry = this.args.registry ?? DEFAULT_MFE_REGISTRY;
 
         return { count, registry, branches };
     }