@servicetitan/startup 32.4.0 → 32.6.0

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

@@ -1,277 +1,72 @@
-import { vol, fs } from 'memfs';
 import { execSync } from 'child_process';
 import { getStartupVersion, log } from '../../../utils';
-import { gitCloneRepo, isCI, npmWhoAmI } from '../../utils';
 
 import { Install } from '../install';
 
-jest.mock('fs', () => fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
-jest.mock('../../utils', () => ({
-    ...jest.requireActual('../../utils'),
-    gitCloneRepo: jest.fn(),
-    isCI: jest.fn(),
-    npmWhoAmI: jest.fn(),
-}));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     getStartupVersion: jest.fn(),
-    log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() }, // suppress log output
+    log: { debug: jest.fn(), info: jest.fn() }, // suppress log output
 }));
 
 describe(`${Install.name}`, () => {
-    const mockNpmToken = 'npm_Foo';
-    const npmOptions = ['--audit=false', '--fund=false', '--legacy-peer-deps'];
     const startupVersion = '1.2.3';
-    const tempDirPath = 'tempDirPath';
     let args: ConstructorParameters<typeof Install>[0];
 
-    function volFromJSON(overrides?: Record<string, string>) {
-        vol.fromJSON({
-            '.npmrc': '',
-            // Mock cloned Github repo with .npm.json containing readOnlyToken
-            [`${tempDirPath}/.npm.json`]: JSON.stringify({
-                readOnlyToken: Buffer.from(mockNpmToken).toString('base64'),
-            }),
-            ...overrides,
-        });
-    }
-
     beforeEach(() => {
         args = {};
         jest.clearAllMocks();
-        jest.mocked(gitCloneRepo).mockResolvedValue(true);
         jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
-        jest.mocked(isCI).mockReturnValue(false);
-        jest.mocked(npmWhoAmI).mockReturnValue(undefined);
-        jest.spyOn(fs, 'mkdtempSync').mockImplementation(() => tempDirPath);
-        volFromJSON();
     });
 
-    afterEach(() => vol.reset());
-
     const subject = async () => new Install(args).execute();
 
-    test('clones "frontend-dev-config" repo to temp directory', async () => {
-        await subject();
-
-        expect(gitCloneRepo).toHaveBeenCalledWith({
-            destination: tempDirPath,
-            name: 'frontend-dev-config',
-        });
-    });
-
-    test('configures NPM token with value from cloned repo', async () => {
-        await subject();
-
-        expect(execSync).toHaveBeenCalledWith(
-            `npm config set "//registry.npmjs.org/:_authToken"="${mockNpmToken}"`
-        );
-    });
-
-    test('deletes NPM token from project .npmrc', async () => {
+    test('runs install', async () => {
         await subject();
 
-        expect(execSync).toHaveBeenCalledWith(
-            `npm config delete --location=project "//registry.npmjs.org/:_authToken"`
-        );
+        expect(execSync).toHaveBeenCalledWith(`npx @servicetitan/install`, { stdio: 'inherit' });
     });
 
-    test('removes temp directory', async () => {
-        const rmSpy = jest.spyOn(fs, 'rmSync');
-
-        await subject();
-
-        expect(rmSpy).toHaveBeenCalledWith(tempDirPath, { recursive: true, force: true });
-    });
-
-    test(`runs npm i ${npmOptions.join(' ')}`, async () => {
-        await subject();
-
-        expect(execSync).toHaveBeenCalledWith(`npm i ${npmOptions.join(' ')}`, {
-            stdio: 'inherit',
-        });
-    });
-
-    test('logs progress', async () => {
-        await subject();
+    describe.each(['fix', 'quiet', 'token'])('with --%s', option => {
+        beforeEach(() => (args[option] = true));
 
-        [`startup cli v${startupVersion}`, 'Configuring NPM token', 'Running npm'].forEach(
-            message => {
-                expect(log.info).toHaveBeenCalledWith(expect.stringMatching(message));
-            }
-        );
-    });
-
-    function itDoesNotConfigureNpmToken() {
-        test('does not configure NPM token', async () => {
-            await subject();
-
-            expect(gitCloneRepo).not.toHaveBeenCalled();
-            expect(execSync).not.toHaveBeenCalledWith(
-                expect.stringMatching(/npm config/),
-                expect.anything()
-            );
-        });
-    }
-
-    function itDoesNotDeleteProjectToken() {
-        test('does not delete project token', async () => {
+        test(`runs install with --${option}`, async () => {
             await subject();
 
-            expect(execSync).not.toHaveBeenCalledWith(
-                expect.stringMatching(/npm config delete/),
+            expect(execSync).toHaveBeenCalledWith(
+                expect.stringContaining(`--${option}`),
                 expect.anything()
             );
         });
-    }
-
-    describe('when "st-team" is already logged in', () => {
-        beforeEach(() => jest.mocked(npmWhoAmI).mockReturnValue('st-team'));
-
-        itDoesNotConfigureNpmToken();
-
-        describe('with --token', () => {
-            beforeEach(() => (args = { token: true }));
-
-            test('configures NPM token', async () => {
-                await subject();
-
-                expect(execSync).toHaveBeenCalledWith(expect.stringMatching(/npm config set/));
-            });
-        });
-    });
-
-    describe('when .npmrc uses an environment variable', () => {
-        beforeEach(() => {
-            volFromJSON({
-                '.npmrc': [
-                    // eslint-disable-next-line no-template-curly-in-string
-                    '#//registry.npmjs.org/:_authToken=${NPM_READONLY_TOKEN}', // should ignore this comment
-                    // eslint-disable-next-line no-template-curly-in-string
-                    '//registry.npmjs.org/:_authToken=${ST_NPM_READONLY_TOKEN}',
-                ].join('\n'),
-            });
-        });
-
-        test('runs npm i with environment variable', async () => {
-            await subject();
-
-            expect(execSync).toHaveBeenCalledWith(`npm i ${npmOptions.join(' ')}`, {
-                // eslint-disable-next-line @typescript-eslint/naming-convention
-                env: expect.objectContaining({ ST_NPM_READONLY_TOKEN: mockNpmToken }),
-                stdio: 'inherit',
-            });
-        });
-
-        itDoesNotDeleteProjectToken();
     });
 
-    describe('with no .npmrc', () => {
-        beforeEach(() => fs.rmSync('.npmrc'));
-
-        itDoesNotDeleteProjectToken();
-    });
-
-    describe('when in CI environment', () => {
-        beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
-
-        test('runs npm ci', async () => {
-            await subject();
-
-            expect(execSync).toHaveBeenCalledWith(`npm ci ${npmOptions.join(' ')}`, {
-                stdio: 'inherit',
-            });
-        });
-
-        itDoesNotConfigureNpmToken();
-    });
-
-    describe('with --quite', () => {
-        beforeEach(() => (args = { quiet: true }));
-
-        test('does not log progress', async () => {
-            await subject();
-
-            expect(log.info).not.toHaveBeenCalled();
-        });
-    });
-
-    describe('with --fix', () => {
-        const fixOptions = [...npmOptions, '--package-lock-only', '--prefer-dedupe'];
-
-        beforeEach(() => (args = { fix: true }));
+    describe('with --no-token', () => {
+        beforeEach(() => (args.token = false));
 
-        test(`runs npm i ${fixOptions.join(' ')}`, async () => {
+        test('runs install with --no-token', async () => {
             await subject();
 
             expect(execSync).toHaveBeenCalledWith(
-                `npm i ${fixOptions.join(' ')}`,
+                expect.stringContaining('--no-token'),
                 expect.anything()
             );
         });
-
-        itDoesNotConfigureNpmToken();
     });
 
-    describe('with --no-token', () => {
-        beforeEach(() => (args = { token: false }));
+    test('logs progress', async () => {
+        await subject();
 
-        itDoesNotConfigureNpmToken();
+        expect(log.info).toHaveBeenCalledWith(`startup cli v${startupVersion}`);
     });
 
-    describe('with --token', () => {
-        beforeEach(() => (args = { token: true }));
-
-        test('does not run "npm i"', async () => {
-            await subject();
-
-            expect(execSync).not.toHaveBeenCalledWith(
-                expect.stringMatching(/npm i/),
-                expect.anything()
-            );
-        });
-    });
+    describe('with --quiet', () => {
+        beforeEach(() => (args = { quiet: true }));
 
-    function itLogsError(message: string | RegExp) {
-        test('logs error', async () => {
+        test('does not log progress', async () => {
             await subject();
 
-            expect(log.warning).toHaveBeenCalledWith(expect.stringMatching(message));
+            expect(log.info).not.toHaveBeenCalled();
         });
-    }
-
-    describe('when error occurs fetching token', () => {
-        beforeEach(() => jest.mocked(gitCloneRepo).mockResolvedValue(false));
-
-        itLogsError(/could not clone servicetitan\/frontend-dev-config/);
-    });
-
-    describe('when .npm.json is not an object', () => {
-        beforeEach(() => volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify('') }));
-
-        itLogsError(/is not an object/);
-    });
-
-    describe('when .npm.json omits readOnlyToken', () => {
-        beforeEach(() => volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({}) }));
-
-        itLogsError(/does not contain auth token/);
-    });
-
-    describe('when readOnlyToken is blank', () => {
-        beforeEach(() =>
-            volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({ readOnlyToken: '' }) })
-        );
-
-        itLogsError(/does not contain auth token/);
-    });
-
-    describe('when readOnlyToken is not a string', () => {
-        beforeEach(() =>
-            volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({ readOnlyToken: {} }) })
-        );
-
-        itLogsError(/token is not a string/);
     });
 });

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

@@ -1,13 +1,15 @@
+import { npmWhoAmI } from '@servicetitan/install';
 import chalk from 'chalk';
 import Table from 'cli-table3';
-import { fs, vol } from 'memfs';
+import { vol } from 'memfs';
 import { createInterface } from 'readline/promises';
 import { formatRelativeDate, toArray } from '../../../utils';
-import { isTTY, npmView, npmWhoAmI, runCommand } from '../../utils';
+import { isTTY, npmView, runCommand } from '../../utils';
 import { MFEList } from '../mfe-list';
 
+jest.mock('@servicetitan/install');
 jest.mock('cli-table3');
-jest.mock('fs', () => fs);
+jest.mock('fs', () => require('memfs').fs);
 jest.mock('readline/promises', () => ({
     createInterface: jest.fn(),
 }));
@@ -15,7 +17,6 @@ jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     isTTY: jest.fn(),
     npmView: jest.fn(),
-    npmWhoAmI: jest.fn(),
     runCommand: jest.fn(),
 }));
 

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/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/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"');
+    }
+}