@servicetitan/startup 32.3.2 → 32.5.0

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

@@ -0,0 +1,32 @@
+import { stylelint } from '../../utils/stylelint';
+import { Stylelint } from '../stylelint';
+
+jest.mock('../../utils/stylelint', () => ({ stylelint: jest.fn() }));
+
+describe(`[startup] ${Stylelint.name}`, () => {
+    let args: ConstructorParameters<typeof Stylelint>[0];
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    beforeEach(() => (args = { _: ['foo'], fix: false }));
+
+    const subject = async () => new Stylelint(args).execute();
+
+    test('runs stylelint with specified args', async () => {
+        await subject();
+
+        expect(stylelint).toHaveBeenCalledWith({ fix: args.fix, paths: args._ });
+    });
+
+    describe('with paths', () => {
+        beforeEach(() => (args.paths = ['bar']));
+
+        test('appends paths to args', async () => {
+            await subject();
+
+            expect(stylelint).toHaveBeenCalledWith({
+                fix: args.fix,
+                paths: [...args._, ...args.paths!],
+            });
+        });
+    });
+});

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

@@ -1,17 +1,14 @@
+import { isCI } from '@servicetitan/install';
 import { execSync } from 'child_process';
-import { vol, fs } from 'memfs';
+import { vol } from 'memfs';
 import { inspect } from 'node:util';
 import path from 'path';
-import { isCI } from '../../utils';
 import { log } from '../../../utils';
 import { UploadSourcemaps } from '../upload-sourcemaps';
 
+jest.mock('@servicetitan/install');
+jest.mock('fs', () => require('memfs').fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
-jest.mock('fs', () => fs);
-jest.mock('../../utils', () => ({
-    ...jest.requireActual('../../utils'),
-    isCI: jest.fn(),
-}));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: { info: jest.fn(), warning: jest.fn() },

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

@@ -17,6 +17,7 @@ import { PreparePackage } from './prepare-package';
 import { Review } from './review';
 import { RunTask } from './run-task';
 import { Start } from './start';
+import { Stylelint } from './stylelint';
 import { StylesCheck } from './styles-check';
 import { Tests } from './test';
 import { Command, Newable } from './types';
@@ -39,6 +40,7 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName['prepare-package']]: PreparePackage,
     [CommandName.review]: Review,
     [CommandName.start]: Start,
+    [CommandName.stylelint]: Stylelint,
     [CommandName['styles-check']]: StylesCheck,
     [CommandName.test]: Tests,
     [CommandName.task]: RunTask,

package/src/cli/commands/init.ts

@@ -1,8 +1,8 @@
+import { gitCloneRepo, gitIsReachable } from '@servicetitan/install';
 import fs from 'fs';
 import path from 'path';
 
 import { log, logErrors } from '../../utils';
-import { gitCloneRepo, gitIsReachable } from '../utils';
 import { Command, CommandArgs } from './types';
 
 interface Args extends CommandArgs {
@@ -28,7 +28,7 @@ export class Init extends Command<Args> {
             throw new Error(`${destination} is not an empty directory`);
         }
 
-        if (await this.cloneRepo(destination)) {
+        if (this.cloneRepo(destination)) {
             log.info(`copied example project to ${destination}`);
             return;
         }
@@ -36,10 +36,12 @@ export class Init extends Command<Args> {
         if (!gitIsReachable({ name: REPO_NAME })) {
             throw new Error(`could not read servicetitan/${REPO_NAME} repository`);
         }
+
+        return Promise.resolve();
     }
 
-    async cloneRepo(destination: string) {
-        const ok = await gitCloneRepo({ destination, name: REPO_NAME });
+    cloneRepo(destination: string) {
+        const ok = gitCloneRepo({ destination, name: REPO_NAME });
         if (!ok) {
             return false;
         }

package/src/cli/commands/install.ts

@@ -1,142 +1,39 @@
 import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log, logErrors, getStartupVersion, readJsonSafe } from '../../utils';
+import { log, logErrors, getStartupVersion } from '../../utils';
 import { Command, CommandArgs } from './types';
-import { gitCloneRepo, isCI, npmWhoAmI } from '../utils';
-
 interface Args extends CommandArgs {
     fix?: boolean;
     quiet?: boolean;
     token?: boolean;
 }
 
-const REPO_NAME = 'frontend-dev-config';
-const AUTH_TOKEN_KEY = '//registry.npmjs.org/:_authToken';
-const AUTH_TOKEN_REGEX = /^\/\/registry\.npmjs\.org\/:_authToken=\s*\${([^}]+)}/m;
-
 export class Install extends Command<Args> {
     static readonly description = 'Install project dependencies';
     static readonly options = {
         fix: { boolean: true, describe: 'Update and dedupe package-lock.json', hidden: true },
-        quite: { boolean: true, describe: 'Suppress output', hidden: true },
+        quiet: { boolean: true, describe: 'Suppress output', hidden: true },
         token: { boolean: true, describe: 'Configure npm token' },
     };
 
     @logErrors
     async execute() {
-        if (!this.args?.quiet) {
+        if (!this.args.quiet) {
             log.info(`startup cli v${getStartupVersion()}`);
         }
 
-        const env = await this.configureNpmToken();
+        const options = [
+            this.args.fix ? '--fix' : '',
+            this.args.quiet ? '--quiet' : '',
+            this.args.token === true ? '--token' : '',
+            this.args.token === false ? '--no-token' : '',
+        ].filter(option => !!option);
 
-        if (this.args?.token !== true) {
-            this.installPackages(env);
-        }
+        const command = `npx @servicetitan/install ${options.join(' ')}`.trim();
 
-        return Promise.resolve(); // stops "async method has no 'await' expression" lint error
-    }
-
-    private async configureNpmToken() {
-        if (isCI() || this.args?.fix || this.args?.token === false) {
-            return;
-        }
-
-        if (!this.args?.quiet) {
-            log.info('Configuring NPM token ...');
-        }
+        log.debug('install', command);
 
-        if (this.args?.token !== true) {
-            const npmUser = npmWhoAmI();
-            /* istanbul ignore next: debug only */
-            log.debug('install:npm-user', () => JSON.stringify({ npmUser }));
-            if (npmUser === 'st-team') {
-                return;
-            }
-        }
-
-        const token = await this.fetchNpmToken();
-        if (!token) {
-            return;
-        }
-
-        execSync(`npm config set "${AUTH_TOKEN_KEY}"="${token}"`);
-
-        if (!fs.existsSync('.npmrc')) {
-            return;
-        }
-
-        const npmrc = fs.readFileSync('.npmrc', 'utf-8');
-        const match = AUTH_TOKEN_REGEX.exec(npmrc);
-        if (match) {
-            return { [match[1]]: token };
-        }
+        execSync(command, { stdio: 'inherit' });
 
-        execSync(`npm config delete --location=project "${AUTH_TOKEN_KEY}"`);
-    }
-
-    private async fetchNpmToken() {
-        const tempDirPath = fs.mkdtempSync(path.join(os.tmpdir(), 'st-install-'));
-        try {
-            if (!(await gitCloneRepo({ destination: tempDirPath, name: REPO_NAME }))) {
-                throw new Error(`could not clone servicetitan/${REPO_NAME}`);
-            }
-
-            const npmJson = readJsonSafe(path.join(tempDirPath, '.npm.json'));
-
-            /* istanbul ignore next: debug only */
-            log.debug('install:fetch-token', () => JSON.stringify(npmJson, null, 2));
-
-            if (!((npmJson && typeof npmJson === 'object') || Array.isArray(npmJson))) {
-                throw new Error('.npm.json is not an object');
-            }
-
-            const { readOnlyToken: authToken } = npmJson;
-            if (!authToken) {
-                throw new Error('.npm.json does not contain auth token');
-            }
-
-            if (typeof authToken !== 'string') {
-                throw new Error('.npm.json auth token is not a string');
-            }
-
-            return Buffer.from(authToken, 'base64').toString('utf-8');
-        } catch (e) {
-            log.warning(String(e));
-        } finally {
-            try {
-                fs.rmSync(tempDirPath, { recursive: true, force: true });
-            } catch {
-                // ignore
-            }
-        }
-    }
-
-    private installPackages(env?: Record<string, string>) {
-        /* istanbul ignore next: debug only */
-        log.debug('install:install-packages', () => JSON.stringify({ env }));
-
-        /**
-         * Note, if these are changed, update bootstrap.js to match
-         * @see {@link file://./../../../../../bootstrap.js}
-         */
-        const npmArguments = [
-            isCI() ? 'ci' : 'i',
-            '--audit=false',
-            '--fund=false',
-            '--legacy-peer-deps',
-            ...(this.args?.fix ? ['--package-lock-only', '--prefer-dedupe'] : []),
-        ].join(' ');
-
-        if (!this.args?.quiet) {
-            log.info(`Running npm ${npmArguments} ...`);
-        }
-
-        execSync(`npm ${npmArguments}`, {
-            ...(env ? { env: { ...process.env, ...env } } : {}),
-            stdio: 'inherit',
-        });
+        return Promise.resolve(); // stops "async method has no 'await' expression" lint error
     }
 }

package/src/cli/commands/lint.ts

@@ -1,17 +1,8 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import path from 'path';
-
-import stylelint from 'stylelint';
-
-import {
-    getDestinationFolders,
-    getPackages,
-    getStylelintConfiguration,
-    log,
-    logErrors,
-} from '../../utils';
+import { getPackages, log, logErrors } from '../../utils';
 import { Command, CommandArgs } from './types';
 import { eslint, lernaExec } from '../utils';
+import { stylelint } from '../utils/stylelint';
 
 interface Args extends CommandArgs {
     _: string[];
@@ -61,58 +52,19 @@ export class Lint extends Command<Args> {
 
     @logErrors
     private async stylelint() {
-        const { disabled, ...config } = getStylelintConfiguration();
-        if (disabled) {
-            return;
-        }
-
-        const { fix } = this.args;
-        const { paths } = this;
-
         log.info('Running stylelint...');
-        const allowedExtensions = ['css', 'scss', 'less'];
-        const glob = `**/*.{${allowedExtensions.join(',')}}`;
-        let files = paths.reduce((result, path) => {
-            const extension = path.split('.').pop();
-            if (extension) {
-                if (allowedExtensions.includes(extension.toLowerCase())) {
-                    result.push(path);
-                }
-            } else {
-                result.push(pathUniJoin(path, glob));
-            }
-            return result;
-        }, new Array<string>());
-
-        if (!files.length) {
-            files = [glob];
-        }
-
-        const { report, errored } = await stylelint.lint({
-            files,
-            ignorePattern: ['node_modules', ...getDestinationFolders()],
-            formatter: 'string',
-            fix,
-            quietDeprecationWarnings: true,
-            ...config,
-        });
-
-        process.stdout.write(report);
-
-        if (errored) {
-            process.exitCode = 1;
-        }
+        await stylelint({ fix: this.args.fix, paths: this.paths });
     }
 
     @logErrors
     private async checkStyles() {
         const { ignore, scope } = this.args;
 
-        const packages = getPackages({ ignore, scope });
+        const packages = ignore || scope ? getPackages({ ignore, scope }) : undefined;
 
         await lernaExec({
             cmd: 'startup styles-check',
-            scope: packages.map(({ name }) => name),
+            scope: packages?.map(({ name }) => name),
             stream: true,
         });
     }
@@ -128,7 +80,3 @@ export class Lint extends Command<Args> {
         return [..._, ...paths];
     }
 }
-
-function pathUniJoin(...chunks: string[]) {
-    return path.join(...chunks).replace(/\\/g, '/');
-}

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

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/naming-convention */
+import { npmWhoAmI } from '@servicetitan/install';
 import chalk from 'chalk';
 import Table from 'cli-table3';
 import readline from 'readline/promises';
@@ -11,7 +12,7 @@ import {
     PackageType,
 } from '../../utils';
 import { Command, CommandArgs } from './types';
-import { isTTY, NPMPackageInfo, npmView, npmWhoAmI, runCommand } from '../utils';
+import { isTTY, NPMPackageInfo, npmView, runCommand } from '../utils';
 
 interface Args extends CommandArgs {
     _: string[];

package/src/cli/commands/review/rules/__tests__/no-deprecated-startup-install.test.ts

@@ -0,0 +1,81 @@
+import { execSync } from 'child_process';
+import { FixCategory, Package, PackageError, ReviewConfiguration } from '../../types';
+import { mockProject } from '../__mocks__';
+
+import { NoDeprecatedStartupInstall } from '../no-deprecated-startup-install';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${NoDeprecatedStartupInstall.name}`, () => {
+    const id = 'no-deprecated-startup-install';
+    const rule = new NoDeprecatedStartupInstall();
+    let config: ReviewConfiguration;
+    let pkg: Package;
+    let packages: Package[];
+
+    beforeEach(() => {
+        config = {};
+        pkg = { name: 'project', location: '.' };
+        packages = [pkg];
+        jest.clearAllMocks();
+    });
+
+    const subject = () => rule.run(mockProject({ config, packages }));
+
+    const fixSubject = () => rule.fix(subject()!);
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toBeUndefined();
+        });
+    }
+
+    function itReturnsError() {
+        test('returns error', () => {
+            expect(subject()).toEqual({
+                id,
+                message: 'project uses deprecated "@servicetitan/startup install" script',
+                location: pkg.location,
+                fixable: FixCategory.isolated,
+            } satisfies PackageError);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when project uses deprecated bootstrap script', () => {
+        beforeEach(() => {
+            pkg.scripts = { bootstrap: 'npx --yes @servicetitan/startup install' };
+        });
+
+        itReturnsError();
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expect(execSync).toHaveBeenCalledWith(
+                'npm pkg set scripts.bootstrap="npx --yes @servicetitan/install"'
+            );
+        });
+
+        describe('when script includes version tag', () => {
+            beforeEach(() => {
+                pkg.scripts!.bootstrap = 'npx --yes @servicetitan/startup@30.0.0 install';
+            });
+
+            itReturnsError();
+        });
+    });
+
+    describe('with no root package', () => {
+        beforeEach(() => (packages = []));
+
+        itReturnsNothing();
+    });
+
+    test('ignores invalid error', () => {
+        rule.fix({} as any);
+
+        expect(execSync).not.toHaveBeenCalled();
+    });
+});

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

@@ -1,5 +1,6 @@
 import { PackageRule } from '../types';
 import { NoDeprecatedContentBase } from './no-deprecated-content-base';
+import { NoDeprecatedStartupInstall } from './no-deprecated-startup-install';
 import { NoDirectPeerDependencies } from './no-direct-peer-dependencies';
 import { NoTypescriptEntryPoint } from './no-typescript-entry-point';
 import { PreferOpenEndedPeerDependencies } from './prefer-open-ended-peer-dependencies';
@@ -24,6 +25,7 @@ export const rules: PackageRule[] = [
     new RequireCompatibleLaunchDarklySdk(),
     new NoDeprecatedContentBase(),
     new NoDirectPeerDependencies(),
+    new NoDeprecatedStartupInstall(),
     new NoTypescriptEntryPoint(),
     new PreferOpenEndedPeerDependencies(),
     new RequireServiceTitanScope(),

package/src/cli/commands/review/rules/no-deprecated-startup-install.ts

@@ -0,0 +1,30 @@
+import { execSync } from 'child_process';
+import { FixCategory, PackageError, PackageRule, Project } from '../types';
+
+export class NoDeprecatedStartupInstall implements PackageRule {
+    get id() {
+        return 'no-deprecated-startup-install';
+    }
+
+    run(project: Project): PackageError | undefined {
+        const root = project.packages.find(({ location }) => location === '.');
+        const bootstrap = root?.scripts?.bootstrap;
+
+        if (bootstrap && /@servicetitan\/startup.* install/.test(bootstrap)) {
+            return {
+                id: this.id,
+                message: 'project uses deprecated "@servicetitan/startup install" script',
+                location: root.location,
+                fixable: FixCategory.isolated,
+            };
+        }
+    }
+
+    fix({ location }: PackageError) {
+        if (!location) {
+            return;
+        }
+
+        execSync('npm pkg set scripts.bootstrap="npx --yes @servicetitan/install"');
+    }
+}

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

@@ -45,6 +45,7 @@ export interface Package {
     name: string;
     peerDependencies?: Record<string, string>;
     private?: boolean;
+    scripts?: Record<string, string>;
     sideEffects?: any;
     workspaces?: string[];
 }

package/src/cli/commands/stylelint.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { logErrors } from '../../utils';
+import { stylelint } from '../utils/stylelint';
+import { Command, CommandArgs } from './types';
+
+interface Args extends CommandArgs {
+    _: string[];
+    fix?: boolean;
+    paths?: string[];
+}
+
+export class Stylelint extends Command<Args> {
+    static readonly options = {
+        _: { description: '[paths...]' },
+    };
+
+    @logErrors
+    async execute() {
+        await stylelint({ fix: this.args.fix, paths: this.paths });
+    }
+
+    private get paths() {
+        const { _, paths = [] } = this.args;
+        return [..._, ...paths];
+    }
+}

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

@@ -1,7 +1,8 @@
+import { isCI } from '@servicetitan/install';
 import path from 'path';
 import { execSync } from 'child_process';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
-import { isCI, TSConfig } from '../utils';
+import { TSConfig } from '../utils';
 import { Command, CommandArgs } from './types';
 
 interface Args extends CommandArgs {