@servicetitan/startup 29.0.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/run-task.ts

@@ -0,0 +1,41 @@
+import { log, logErrors } from '../../utils';
+import { Command } from './types';
+import { SwcCompilePackage } from '../tasks/swc-compile-package';
+import { TscCompilePackage } from '../tasks/tsc-compile-package';
+import { TscCompile } from '../tasks/tsc-compile';
+import { Task } from '../tasks/task';
+
+interface Args {
+    [key: string]: unknown;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    _: string[];
+}
+
+const tasks: Record<string, new (args: Args) => Task> = {
+    'tsc-compile-package': TscCompilePackage,
+    'swc-compile-package': SwcCompilePackage,
+    'tsc-compile': TscCompile,
+};
+
+export class RunTask implements Command {
+    constructor(private readonly args: Args) {}
+
+    description() {
+        return undefined;
+    }
+
+    @logErrors
+    async execute() {
+        const taskName = this.args._[0];
+
+        if (taskName in tasks) {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            const trimArgs = { ...this.args, _: this.args._.slice(1) };
+            await new tasks[taskName](trimArgs).execute();
+            return;
+        }
+
+        log.error(`Unknown task: "${taskName}"`);
+        log.text(`\nSupported tasks: "${Object.keys(tasks).join('", "')}"`);
+    }
+}

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 import execa from 'execa';
+import path from 'path';
 import { argv, Arguments } from 'yargs';
 import { CommandName, getStartupVersion, log } from '../utils';
 import { getCommand, getUserCommands } from './commands';
@@ -20,6 +21,7 @@ if (!Command) {
     process.exit(127);
 }
 
+checkNodeVersion();
 maybeCreateGitFolder(Command);
 
 if (setNodeOptions(name)) {
@@ -36,15 +38,25 @@ if (setNodeOptions(name)) {
 }
 
 function usage() {
-    write('\nUsage:\n');
+    log.text('\nUsage:');
 
     const commands = getUserCommands().filter(({ name }) => !!name);
     const maxNameLength = commands.reduce((result, { name }) => Math.max(result, name.length), 0);
     commands.forEach(({ name, description }) => {
-        write(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
+        log.text(`startup ${name.padEnd(maxNameLength, ' ')}  ${description}`);
     });
 }
 
-function write(text: string) {
-    return console.info(text); // eslint-disable-line no-console
+function checkNodeVersion() {
+    const nodeVersion = Number(process.versions.node.split('.')[0]);
+    if (nodeVersion % 2 === 0 || process.env.SKIP_NODE_VERSION_CHECK) {
+        return;
+    }
+
+    const { engines } = require(path.join(__dirname, '../../package.json'));
+    log.error(
+        `error: node v${nodeVersion} detected, only even-numbered LTS versions ${engines.node} are supported`
+    );
+    log.text('See https://nodejs.org/en/download for LTS versions');
+    process.exit(127);
 }

package/src/cli/tasks/__tests__/cli-task.test.ts

@@ -0,0 +1,115 @@
+import execa from 'execa';
+import { log } from '../../../utils';
+import { CliTask, Indicators } from '../cli-task';
+
+jest.mock('execa', () =>
+    jest.fn().mockReturnValue(
+        Object.assign(Promise.resolve(), {
+            stdout: {
+                on: jest.fn(),
+            },
+        })
+    )
+);
+
+jest.mock('../../../utils', () => ({
+    getFolders: jest.fn().mockReturnValue({
+        source: 'src',
+        destination: 'dist',
+    }),
+    log: { info: jest.fn() },
+    readJsonSafe: jest.fn().mockReturnValue({}),
+}));
+
+const taskName = 'cli-task-impl';
+const indicators: Required<Indicators> = {
+    end: 'Watching for file changes.',
+    watchStart: 'Starting incremental compilation.',
+    watchEnd: 'Watching changes.',
+};
+
+class CliTaskImpl extends CliTask {
+    constructor({ watch }: { watch: boolean }) {
+        super({ name: taskName, global: false, watch, indicators });
+    }
+
+    description() {
+        return '';
+    }
+
+    async execute(): Promise<void> {
+        await this.runChildProcess('', []);
+    }
+}
+
+describe(`[startup] ${CliTask.name} task`, () => {
+    beforeEach(() => {
+        globalThis.performance.clearMarks();
+        globalThis.performance.clearMeasures();
+        jest.clearAllMocks();
+    });
+
+    let watch = false;
+
+    const subject = () => new CliTaskImpl({ watch }).execute();
+
+    test('logs completion message', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringContaining(`${taskName} task completed in`)
+        );
+    });
+
+    describe('in watch mode', () => {
+        beforeEach(() => (watch = true));
+
+        describe('onData handler', () => {
+            beforeEach(() => subject());
+
+            const onDataHandler = (data: string) => {
+                jest.mocked(jest.mocked(execa).mock.results[0].value.stdout.on).mock.calls[0][1](
+                    data
+                );
+            };
+
+            function itLogsInitialBuild(event: keyof Indicators) {
+                test('logs duration of initial build', () => {
+                    onDataHandler(indicators[event]);
+
+                    expect(log.info).toHaveBeenCalledWith(
+                        expect.stringContaining(`Initial ${taskName} task completed in`)
+                    );
+                });
+            }
+
+            function itLogsSubsequentBuild(event: keyof Indicators) {
+                test('logs duration of subsequent build', () => {
+                    onDataHandler(indicators[event]!);
+
+                    expect(log.info).toHaveBeenCalledWith(
+                        expect.stringContaining(`Subsequent ${taskName} task completed in`)
+                    );
+                });
+            }
+
+            itLogsInitialBuild('end');
+
+            describe('when subsequent build starts after initial build ends', () => {
+                beforeEach(() => {
+                    onDataHandler(indicators.end);
+                    onDataHandler(indicators.watchStart);
+                });
+
+                itLogsSubsequentBuild('end');
+                itLogsSubsequentBuild('watchEnd');
+            });
+
+            describe('when subsequent build starts before initial build ends', () => {
+                beforeEach(() => onDataHandler(indicators.watchStart));
+
+                itLogsSubsequentBuild('watchEnd');
+            });
+        });
+    });
+});