@servicetitan/startup 28.5.0 → 30.0.0

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

@@ -0,0 +1,289 @@
+import execa from 'execa';
+import fs from 'fs';
+import { globSync } from 'glob';
+import JSON5 from 'json5';
+
+import { log, logErrors, toArray } from '../../utils';
+import { Command } from './types';
+
+const oldConfigFile = '.eslintrc.json';
+const newConfigFile = 'eslint.config.mjs';
+const eslintIgnoreFile = '.eslintignore';
+
+interface Override {
+    [key: string]: unknown;
+    files?: string[];
+}
+
+interface V8Config {
+    extends?: string | string[];
+    ignorePatterns?: string[];
+    overrides?: Override[];
+    plugins?: string[];
+    parserOptions?: Record<string, unknown>;
+    rules?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+}
+
+interface Context {
+    flatConfigs: string[];
+    imports: {
+        [key: string]: string | string[];
+        'eslint/config': string[];
+    };
+    source: V8Config;
+}
+
+interface Recipe {
+    config: string;
+    files?: string[];
+    import: { as: string; from?: string };
+}
+
+export class ConvertEslintConfig implements Command {
+    private static readonly recipes: Record<string, Recipe | null> = {
+        '@servicetitan/eslint-config/mono': {
+            import: { as: 'mono' },
+            config: 'mono',
+        },
+        '@servicetitan/eslint-config/single': {
+            import: { as: 'single' },
+            config: 'single',
+        },
+        'plugin:chai-friendly/recommended': {
+            import: { as: 'pluginChaiFriendly', from: 'eslint-plugin-chai-friendly' },
+            config: 'pluginChaiFriendly.configs.recommendedFlat',
+        },
+        'plugin:cypress/recommended': {
+            import: { as: 'pluginCypress', from: 'eslint-plugin-cypress/flat' },
+            config: 'pluginCypress.configs.recommended',
+        },
+        'plugin:mocha/recommended': {
+            import: { as: 'pluginMocha', from: 'eslint-plugin-mocha' },
+            config: 'pluginMocha.configs.flat.recommended',
+        },
+        'plugin:storybook/recommended': {
+            import: { as: 'storybook', from: 'eslint-plugin-storybook' },
+            config: "storybook.configs['flat/recommended']",
+        },
+        'plugin:testing-library/react': {
+            import: { as: 'pluginTestingLibrary', from: 'eslint-plugin-testing-library' },
+            config: "pluginTestingLibrary.configs['flat/react']",
+            files: ['**/*.test.*'],
+        },
+        'prettier': null,
+    };
+
+    description() {
+        return 'convert v8.x eslintrc.json to v9.x flat config';
+    }
+
+    @logErrors
+    async execute() {
+        if (!fs.existsSync(oldConfigFile)) {
+            throw new Error(`${oldConfigFile} not found`);
+        }
+
+        const configFiles = globSync('eslint.config.{js,cjs,mjs}');
+        if (configFiles.length > 0) {
+            throw new Error(`flat config "${configFiles[0]}" already exists`);
+        }
+
+        log.info(`Processing ${oldConfigFile}`);
+
+        const json = this.readJson(oldConfigFile);
+        fs.writeFileSync(newConfigFile, this.convert(json), 'utf-8');
+        await this.prettify(newConfigFile);
+
+        log.success(`Created ${newConfigFile}`);
+    }
+
+    private convert(source: V8Config) {
+        const context: Context = {
+            flatConfigs: [],
+            imports: { 'eslint/config': ['defineConfig'] },
+            source,
+        };
+
+        const handlers: { [K in keyof V8Config]: (context: Context) => void } = {
+            extends: this.handleExtends.bind(this),
+            overrides: this.handleOverrides.bind(this),
+            parserOptions: this.handleParserOptions.bind(this),
+            plugins: this.handlePlugins.bind(this),
+            rules: this.handleRules.bind(this),
+            settings: this.handleSettings.bind(this),
+        };
+
+        // Don't limit handleIgnores to a specific key because it also reads .eslintignore.rc
+        this.handleIgnores(context);
+
+        // Run handlers in key order to preserve ordering of configs
+        Object.keys(context.source).forEach((key: keyof V8Config) => {
+            handlers[key]?.(context);
+        });
+
+        return this.format(context);
+    }
+
+    private format(context: Context) {
+        return `${this.formatImports(context)}\n\n${this.formatConfigs(context)}`;
+    }
+
+    private formatConfigs(context: Context) {
+        return `export default defineConfig([
+            ${context.flatConfigs.join()}
+        ]);`;
+    }
+
+    private formatImports({ imports }: Context) {
+        return Object.entries(imports)
+            .map(([pkg, itemOrItems]) => {
+                if (typeof itemOrItems === 'string') {
+                    return `import ${itemOrItems} from '${pkg}';`;
+                }
+                return `import { ${itemOrItems.join()} } from '${pkg}';`;
+            })
+            .join('\n');
+    }
+
+    private handleExtends({ flatConfigs, imports, source }: Context) {
+        const unrecognized: string[] = [];
+        const extendsArray = toArray(source.extends);
+
+        extendsArray.forEach(entry => {
+            const recipe = ConvertEslintConfig.recipes[entry];
+            if (recipe) {
+                imports[recipe.import.from ?? entry] = recipe.import.as;
+                if (recipe.files) {
+                    flatConfigs.push(`{
+                        files: ${JSON.stringify(recipe.files)},
+                        ...${recipe.config}
+                    }`);
+                } else {
+                    flatConfigs.push(recipe.config);
+                }
+            } else if (recipe !== null) {
+                unrecognized.push(entry);
+            }
+        });
+
+        /*
+         * Use extends workaround for anything we didn't recognized
+         * https://eslint.org/blog/2025/03/flat-config-extends-define-config-global-ignores/#bringing-back-extends
+         */
+
+        if (unrecognized.length) {
+            flatConfigs.push(JSON.stringify({ extends: unrecognized }));
+        }
+    }
+
+    private handleIgnores({ flatConfigs, imports, source: { ignorePatterns = [] } }: Context) {
+        const globs = ignorePatterns.filter(glob => !!glob);
+
+        if (fs.existsSync(eslintIgnoreFile)) {
+            const fileGlobs = fs
+                .readFileSync(eslintIgnoreFile, 'utf-8')
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => !!line);
+            globs.push(...fileGlobs);
+        }
+
+        if (globs.length === 0) {
+            return;
+        }
+
+        const normalized = globs.map(normalizeGlob);
+
+        imports['eslint/config'].push('globalIgnores');
+        flatConfigs.push(`globalIgnores(${JSON.stringify(normalized)})`);
+    }
+
+    private handleOverrides({
+        flatConfigs,
+        source: { overrides },
+    }: Context & { source: { overrides: NonNullable<Context['source']['overrides']> } }) {
+        overrides.forEach(override => {
+            flatConfigs.push(JSON.stringify(this.handleOverride(override), null, 2));
+        });
+    }
+
+    private handleOverride({ parserOptions, ...rest }: Override) {
+        rest.files = rest.files?.map(normalizeGlob);
+        const languageOptions = parserOptions ? { parserOptions } : undefined;
+        return { ...rest, languageOptions };
+    }
+
+    private handlePlugins({
+        flatConfigs,
+        imports,
+        source,
+    }: Context & { source: { plugins: NonNullable<Context['source']['plugins']> } }) {
+        const plugins: Record<string, string> = {};
+
+        source.plugins.forEach(name => {
+            const camelized = toCamelCase(name);
+            imports[`eslint-plugin-${name}`] = camelized;
+            plugins[name] = camelized;
+        });
+
+        flatConfigs.push(`{
+            plugins: {
+                ${Object.entries(plugins)
+                    .map(([key, value]) => `'${key}': ${value}`)
+                    .join(',\n')}
+            } 
+        }`);
+    }
+
+    private handleParserOptions({ flatConfigs, source: { parserOptions } }: Context) {
+        flatConfigs.push(JSON.stringify({ languageOptions: { parserOptions } }));
+    }
+
+    private handleRules({
+        flatConfigs,
+        source: { rules },
+    }: Context & { source: { rules: NonNullable<Context['source']['rules']> } }) {
+        const tsPrefix = '@typescript-eslint/';
+        const nonTsRules = Object.fromEntries(
+            Object.entries(rules).filter(([key]) => !key.startsWith(tsPrefix))
+        );
+        if (Object.keys(nonTsRules).length) {
+            flatConfigs.push(JSON.stringify({ rules: nonTsRules }, null, 2));
+        }
+
+        const tsRules = Object.fromEntries(
+            Object.entries(rules).filter(([key]) => key.startsWith(tsPrefix))
+        );
+        if (Object.keys(tsRules).length) {
+            flatConfigs.push(JSON.stringify({ files: ['**/*.ts{,x}'], rules: tsRules }, null, 2));
+        }
+    }
+
+    private handleSettings({
+        flatConfigs,
+        source: { settings },
+    }: Context & { source: { settings: NonNullable<Context['source']['settings']> } }) {
+        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'));
+    }
+}
+
+function toCamelCase(str: string) {
+    return str.replace(/(-[a-z])/g, ([, letter]) => letter.toUpperCase());
+}
+
+function normalizeGlob(glob: string) {
+    return glob.includes('/') ? glob.replace(/^(!)?\//, '$1') : `**/${glob}`;
+}

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

@@ -2,6 +2,7 @@ import { CommandName } from '../../utils';
 
 import { Build } from './build';
 import { BundlePackage } from './bundle-package';
+import { ConvertEslintConfig } from './convert-eslint-config';
 import { ESLintCommand } from './eslint';
 import { Init } from './init';
 import { Install } from './install';
@@ -13,6 +14,7 @@ import { MFEPublish } from './mfe-publish';
 import { PreparePackage } from './prepare-package';
 import { Start } from './start';
 import { StylesCheck } from './styles-check';
+import { RunTask } from './run-task';
 import { Tests } from './tests';
 import { Command, Newable } from './types';
 
@@ -22,6 +24,8 @@ export function getCommand(name: CommandName): Newable<Command> | undefined {
             return Build;
         case CommandName['bundle-package']:
             return BundlePackage;
+        case CommandName['convert-eslint-config']:
+            return ConvertEslintConfig;
         case CommandName.eslint:
             return ESLintCommand;
         case CommandName.init:
@@ -46,5 +50,7 @@ export function getCommand(name: CommandName): Newable<Command> | undefined {
             return StylesCheck;
         case CommandName.test:
             return Tests;
+        case CommandName.task:
+            return RunTask;
     }
 }

package/src/cli/commands/init.ts

@@ -37,7 +37,8 @@ export class Init implements Command {
             );
         }
 
-        for await (const url of gitUrls) {
+        for (const url of gitUrls) {
+            // eslint-disable-next-line no-await-in-loop
             if (await cloneRepo(url, destination)) {
                 log.info(`copied example project to ${destination}`);
                 return;
@@ -53,7 +54,7 @@ export class Init implements Command {
 async function cloneRepo(url: string, destination: string) {
     try {
         await runCommand(`git clone -q ${url} ${destination}`, { quiet: true });
-    } catch (e) {
+    } catch {
         return false;
     }
     fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
@@ -65,7 +66,7 @@ async function cloneRepo(url: string, destination: string) {
 function isReachable(url: string) {
     try {
         runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
-    } catch (e) {
+    } catch {
         return false;
     }
     return true;

package/src/cli/commands/lint.ts

@@ -22,7 +22,7 @@ interface Args {
     /** Packages to skip */
     ignore?: string | string[];
     /** Run eslint separately for each package? */
-    isolated?: boolean;
+    parallel?: boolean;
 }
 
 export class Lint implements Command {
@@ -44,10 +44,10 @@ export class Lint implements Command {
 
     @logErrors
     private async eslint() {
-        const { fix, ignore, isolated, scope } = this.args;
+        const { fix, ignore, parallel, scope } = this.args;
         const { paths } = this;
 
-        const useESLint = !isolated && !scope?.length && !ignore?.length;
+        const useESLint = !parallel && !scope?.length && !ignore?.length;
         if (this.paths.length || useESLint) {
             log.info('Running eslint...');
             await eslint({ fix, paths });

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

@@ -1,12 +1,15 @@
 import { isWebComponent, log, logErrors, readJson } from '../../utils';
-import { gitGetBranch } from '../utils/cli-git';
-import { npmGetPackageVersionDates, npmUnpublish } from '../utils/cli-npm';
 import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import { gitGetBranch } from '../utils/cli-git';
+import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../utils/cli-npm';
 import { Command } from './types';
 
 export interface ArgsPackageClean {
-    branch?: string | true;
+    all?: true;
+    branch?: string;
     count?: number;
+    dry?: boolean;
+    registry?: string;
 }
 
 export class MFEPackageClean implements Command {
@@ -23,37 +26,34 @@ export class MFEPackageClean implements Command {
         }
 
         const data = this.getCleanData();
-        const packageJson = readJson('package.json');
-        const packageName = packageJson.name;
+        const packageName = readJson('package.json').name;
         const branchedVersions = this.getBranchedVersions(packageName, data.registry);
 
-        log.info(
-            `branched versions (${data.count}):`,
-            JSON.stringify(branchedVersions, undefined, 4)
-        );
-
-        const branchedVersionsToClean: Record<string, [string, Date][]> = {};
+        log.info(`branched versions (${data.count}):`, JSON.stringify(branchedVersions, null, 2));
 
-        for (const branch of Object.keys(branchedVersions)) {
-            // limit branches for now
-            if (!branchedVersions[branch] || !data.branches.includes(branch)) {
+        const branchedVersionsToClean: Record<string, Version[]> = {};
+        for (const [branch, versions] of Object.entries(branchedVersions)) {
+            // Limit branches for now
+            if (!data.branches.includes(branch)) {
+                log.info(`ignoring unrecognized branch "${branch}"`);
                 continue;
             }
 
-            branchedVersions[branch].sort(([, adt], [, bdt]) => (adt > bdt ? -1 : 1));
-            branchedVersionsToClean[branch] = branchedVersions[branch].slice(data.count);
+            branchedVersionsToClean[branch] = this.excludeTagged(versions)
+                .sort(({ date: adt }, { date: bdt }) => (adt > bdt ? -1 : 1))
+                .slice(data.count);
         }
 
-        log.info(
-            'found versions for unpublish:',
-            JSON.stringify(branchedVersionsToClean, undefined, 4)
-        );
-
+        log.info('found versions for unpublish:', JSON.stringify(branchedVersionsToClean, null, 2));
         const unVersions = Object.keys(branchedVersionsToClean).reduce(
-            (out, br) => [...out, ...branchedVersionsToClean[br].map(([v]) => v)],
+            (out, br) => [...out, ...branchedVersionsToClean[br].map(({ name }) => name)],
             []
         );
 
+        if (this.args.dry) {
+            return;
+        }
+
         for (const version of unVersions) {
             try {
                 // eslint-disable-next-line no-await-in-loop
@@ -64,6 +64,16 @@ export class MFEPackageClean implements Command {
         }
     }
 
+    private excludeTagged(versions: Version[]) {
+        return versions.filter(({ name, tag }) => {
+            if (tag) {
+                log.info(`ignoring version ${name} tagged "${tag}"`);
+                return false;
+            }
+            return true;
+        });
+    }
+
     private getCleanData(): {
         count: number;
         registry: string;
@@ -76,66 +86,57 @@ export class MFEPackageClean implements Command {
 
         let branches: string[];
 
-        if (this.args.branch === true) {
-            branches = [gitGetBranch()];
+        if (this.args.all === true) {
+            branches = Object.keys(getBranchesConfigs());
         } else if (typeof this.args.branch === 'string') {
             branches = [this.args.branch];
         } else {
-            branches = Object.keys(getBranchesConfigs());
+            branches = [gitGetBranch()];
         }
 
-        const registry = 'https://verdaccio.servicetitan.com';
+        const registry = this.args.registry ?? 'https://verdaccio.servicetitan.com';
 
         return { count, registry, branches };
     }
 
     private getBranchedVersions(packageName: string, registry: string) {
-        const versions = npmGetPackageVersionDates(registry, packageName);
-        const branchedVersions: Record<string, [string, Date][]> = {};
-        const unknownVersions: string[] = [];
-
-        const addVersion = (branch: string, version: string, dt: Date) => {
-            if (!branchedVersions[branch]) {
-                branchedVersions[branch] = [];
-            }
+        const versions = npmGetPackageVersionsDetails(registry, packageName);
+        const branchedVersions: Record<string, Version[]> = {};
 
-            branchedVersions[branch].push([version, dt]);
-        };
+        function addVersion(branch: string, version: Version) {
+            branchedVersions[branch] ??= [];
+            branchedVersions[branch].push(version);
+        }
 
-        for (const [version, dt] of versions) {
-            if (!version.startsWith('0.0.0-')) {
+        for (const version of versions) {
+            const { name } = version;
+            if (!name.startsWith('0.0.0-')) {
                 continue;
             }
 
-            const buildVersion = version.replace('0.0.0-', '');
+            const buildVersion = name.replace('0.0.0-', '');
 
+            // master version generated by nerdbank versioning
             if (/^(\d+)\.(\d+)\.(\d+)$/.test(buildVersion)) {
-                // master version generated by nerdbank versioning
-                addVersion('master', version, dt);
+                addVersion('master', version);
                 continue;
             }
 
+            // branch version generated by nerdbank versioning
             const match1 = buildVersion.match(/^(\d+)\.(\d+)\.(\d+)-([\dA-Za-z-]+).([\dA-Za-z]+)$/);
-
             if (match1?.length) {
-                // branch version generated by nerdbank versioning
-                addVersion(match1[4], version, dt);
+                addVersion(match1[4], version);
                 continue;
             }
 
+            // branch version generated by mfe-publisher versioning
             const match2 = buildVersion.match(/^([\dA-Za-z-]+).([\dA-Za-z]+)$/);
-
             if (match2?.length) {
-                // branch version generated by mfe-publisher versioning
-                addVersion(match2[1], version, dt);
+                addVersion(match2[1], version);
                 continue;
             }
 
-            unknownVersions.push(version);
-        }
-
-        if (unknownVersions.length) {
-            log.info('unknown versions:', unknownVersions.join());
+            log.info(`skipping unrecognized version: ${name}`);
         }
 
         return branchedVersions;

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

@@ -2,13 +2,7 @@ import path from 'path';
 import fs from 'fs';
 import { getFolders, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { gitGetBranch, gitGetCommitHash } from '../utils/cli-git';
-import {
-    npmGetPackageVersions,
-    npmPackageSet,
-    npmPublish,
-    npmPublishDry,
-    npmTagVersion,
-} from '../utils/cli-npm';
+import { npmGetPackageVersions, npmPackageSet, npmPublish, npmTagVersion } from '../utils/cli-npm';
 import { getBranchesConfigs } from '../../utils/get-branch-configs';
 import { getDefaultBuildVersion } from '../utils/publish';
 import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
@@ -20,7 +14,7 @@ export interface ArgsPackagePublish {
     dry?: boolean;
     force?: boolean;
     registry?: string;
-    tag?: string | false;
+    tag?: string;
 }
 
 export class MFEPackagePublish implements Command {
@@ -92,11 +86,7 @@ export class MFEPackagePublish implements Command {
             await npmPackageSet('files[1]', 'package.json');
         }
 
-        if (data.dry) {
-            await npmPublishDry();
-        } else {
-            await npmPublish(data.tag);
-        }
+        await npmPublish({ dry: data.dry, tag: data.tag || data.fallbackTag });
 
         log.info(`${dryRunPrefix}published ${packageName} version ${data.version}`);
     }
@@ -104,11 +94,12 @@ export class MFEPackagePublish implements Command {
     private getPublishData(): {
         version: string;
         buildVersion: string;
-        tag?: string;
+        tag: string;
         registry: string;
         dry: boolean;
         force: boolean;
         isBranchConfigured: boolean;
+        fallbackTag: string;
     } {
         const cli = this.args;
         const branch = cli.branch ?? gitGetBranch();
@@ -119,15 +110,9 @@ export class MFEPackagePublish implements Command {
             buildVersion = getDefaultBuildVersion(branch, gitGetCommitHash());
         }
 
-        if (!buildVersion) {
-            throw new Error('build version is not set');
-        }
-
         let tag: string;
 
-        if (cli.tag === false) {
-            tag = '';
-        } else if (cli.tag) {
+        if (cli.tag) {
             tag = cli.tag;
         } else {
             tag = branchConfig?.publishTag ?? '';
@@ -143,6 +128,7 @@ export class MFEPackagePublish implements Command {
             dry: !!cli.dry,
             force: !!cli.force,
             isBranchConfigured: !!branchConfig,
+            fallbackTag: 'latest',
         };
     }
 

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

@@ -58,17 +58,18 @@ export class MFEPublish implements Command {
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[registry && `--registry ${registry}`],
-            ...[tag && `--tag ${tag}`],
-            ...[tag === false && `--no-tag`],
+            ...[typeof tag === 'string' && `--tag ${tag}`],
         ].filter(item => !!item) as string[];
     }
 
     getCleanOptions() {
-        const { branch, count } = this.args as ArgsPackageClean;
+        const { all, branch, count, dry, registry } = this.args as ArgsPackageClean;
         return [
-            ...[branch && typeof branch === 'string' && `--branch ${branch}`],
-            ...[branch && branch === true && '--branch'],
+            ...[all && '--all'],
+            ...[typeof branch === 'string' && `--branch ${branch}`],
             ...[count && `--count ${count}`],
+            ...[dry && '--dry'],
+            ...[registry && `--registry ${registry}`],
         ].filter(item => !!item) as string[];
     }
 }