@servicetitan/startup 31.6.0 → 32.0.0

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

@@ -1,33 +1,92 @@
+import { vol, fs } from 'memfs';
 import { execSync } from 'child_process';
-import { log } from '../../../utils';
+import { getStartupVersion, log } from '../../../utils';
+import { gitCloneRepo, isCI } 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(),
+}));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
-    log: { info: jest.fn() }, // suppress log output
+    getStartupVersion: jest.fn(),
+    log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() }, // suppress log output
 }));
 
 describe(`${Install.name}`, () => {
-    const OLD_ENV = process.env;
-    const options = ['--audit=false', '--fund=false', '--legacy-peer-deps'];
+    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(() => {
-        process.env = {};
         args = undefined;
         jest.clearAllMocks();
+        jest.mocked(gitCloneRepo).mockResolvedValue(true);
+        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
+        jest.mocked(isCI).mockReturnValue(false);
+        jest.spyOn(fs, 'mkdtempSync').mockImplementation(() => tempDirPath);
+        volFromJSON();
     });
 
-    afterEach(() => (process.env = OLD_ENV));
+    afterEach(() => vol.reset());
 
     const subject = async () => new Install(args).execute();
 
-    test(`runs npm i ${options.join(' ')}`, async () => {
+    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 () => {
+        await subject();
+
+        expect(execSync).toHaveBeenCalledWith(
+            `npm config delete --location=project "//registry.npmjs.org/:_authToken"`
+        );
+    });
+
+    test('removes temp directory', async () => {
+        const rmSpy = jest.spyOn(fs, 'rmSync');
+
         await subject();
 
-        expect(execSync).toHaveBeenCalledWith(`npm i ${options.join(' ')}`, {
+        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',
         });
     });
@@ -35,19 +94,72 @@ describe(`${Install.name}`, () => {
     test('logs progress', async () => {
         await subject();
 
-        expect(log.info).toHaveBeenCalled();
+        [`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(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config/));
+        });
+    }
+
+    function itDoesNotDeleteProjectToken() {
+        test('does not delete project token', async () => {
+            await subject();
+
+            expect(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config delete/));
+        });
+    }
+
+    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(() => (process.env.CI = 'true'));
+        beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
 
         test('runs npm ci', async () => {
             await subject();
 
-            expect(execSync).toHaveBeenCalledWith(`npm ci ${options.join(' ')}`, {
+            expect(execSync).toHaveBeenCalledWith(`npm ci ${npmOptions.join(' ')}`, {
                 stdio: 'inherit',
             });
         });
+
+        itDoesNotConfigureNpmToken();
     });
 
     describe('with --quite', () => {
@@ -61,7 +173,7 @@ describe(`${Install.name}`, () => {
     });
 
     describe('with --fix', () => {
-        const fixOptions = [...options, '--package-lock-only', '--prefer-dedupe'];
+        const fixOptions = [...npmOptions, '--package-lock-only', '--prefer-dedupe'];
 
         beforeEach(() => (args = { fix: true }));
 
@@ -73,5 +185,55 @@ describe(`${Install.name}`, () => {
                 expect.anything()
             );
         });
+
+        itDoesNotConfigureNpmToken();
+    });
+
+    describe('with --no-token', () => {
+        beforeEach(() => (args = { token: false }));
+
+        itDoesNotConfigureNpmToken();
+    });
+
+    function itLogsError(message: string | RegExp) {
+        test('logs error', async () => {
+            await subject();
+
+            expect(log.warning).toHaveBeenCalledWith(expect.stringMatching(message));
+        });
+    }
+
+    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-package-clean.test.ts

@@ -1,7 +1,6 @@
 import { fs, vol } from 'memfs';
 import { isWebComponent, log } from '../../../utils';
-import { gitGetBranch } from '../../utils/cli-git';
-import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../../utils/cli-npm';
+import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../../utils';
 
 import { MFEPackageClean } from '../mfe-package-clean';
 
@@ -11,13 +10,11 @@ jest.mock('../../../utils', () => ({
     isWebComponent: jest.fn(),
     log: { error: jest.fn(), info: jest.fn() },
 }));
-jest.mock('../../utils/cli-npm', () => ({
+jest.mock('../../utils', () => ({
+    gitGetBranch: jest.fn(),
     npmGetPackageVersionsDetails: jest.fn(),
     npmUnpublish: jest.fn(),
 }));
-jest.mock('../../utils/cli-git', () => ({
-    gitGetBranch: jest.fn(),
-}));
 
 const DEFAULT_VERSIONS_TO_KEEP = 5;
 

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

@@ -1,14 +1,15 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
 import { isWebComponent, log, readJson, WebComponentBranchConfigs } from '../../../utils';
-import { gitGetBranch, gitGetCommitHash } from '../../utils/cli-git';
 import {
+    gitGetBranch,
+    gitGetCommitHash,
     npmGetPackageVersions,
     npmPackageSet,
     npmPublish,
     npmTagVersion,
-} from '../../utils/cli-npm';
-import { runCommand } from '../../utils/cli-os';
+    runCommand,
+} from '../../utils';
 import { MFEPackagePublish } from '../mfe-package-publish';
 
 jest.mock('fs', () => fs);
@@ -17,17 +18,14 @@ jest.mock('../../../utils', () => ({
     isWebComponent: jest.fn(),
     log: { info: jest.fn(), warning: jest.fn() },
 }));
-jest.mock('../../utils/cli-git', () => ({
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
     gitGetBranch: jest.fn(),
     gitGetCommitHash: jest.fn(),
-}));
-jest.mock('../../utils/cli-npm', () => ({
     npmGetPackageVersions: jest.fn(),
     npmPackageSet: jest.fn(),
     npmPublish: jest.fn(),
     npmTagVersion: jest.fn(),
-}));
-jest.mock('../../utils/cli-os', () => ({
     runCommand: jest.fn(),
 }));
 

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

@@ -2,11 +2,16 @@ import { execSync } from 'child_process';
 import { vol, fs } 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('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() },
@@ -33,6 +38,7 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
 
         // eslint-disable-next-line @typescript-eslint/naming-convention
         process.env = { DATADOG_API_KEY: 'datadog-api-key' };
@@ -91,9 +97,7 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
         itThrowsError('DATADOG_API_KEY environment variable is not set');
 
         describe('when in CI environment', () => {
-            beforeEach(() => (process.env.CI = '1'));
-
-            afterEach(() => delete process.env.CI);
+            beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
 
             test('logs warning', async () => {
                 await subject();

package/src/cli/commands/init.ts

@@ -2,15 +2,14 @@ import fs from 'fs';
 import path from 'path';
 
 import { log, logErrors } from '../../utils';
-import { runCommand, runCommandOutput } from '../utils/cli-os';
-import { Command } from './';
+import { gitCloneRepo, gitIsReachable } from '../utils';
+import { Command } from './types';
 
 interface Args {
     output?: string;
 }
 
-const webUrl = 'https://github.com/servicetitan/frontend-example.git';
-const sshUrl = 'git@github.com:servicetitan/frontend-example.git';
+const REPO_NAME = 'frontend-example';
 
 export class Init implements Command {
     constructor(private readonly args: Args) {}
@@ -30,44 +29,25 @@ export class Init implements Command {
             throw new Error(`${destination} is not an empty directory`);
         }
 
-        const gitUrls = [webUrl, sshUrl];
-        if (!!process.env.CI && !!process.env.GITHUB_TOKEN) {
-            gitUrls.unshift(
-                webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)
-            );
+        if (await this.cloneRepo(destination)) {
+            log.info(`copied example project to ${destination}`);
+            return;
         }
 
-        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;
-            }
-        }
-
-        if (!gitUrls.some(isReachable)) {
-            throw new Error('could not read servicetitan/frontend-example repository');
+        if (!gitIsReachable({ name: REPO_NAME })) {
+            throw new Error(`could not read servicetitan/${REPO_NAME} repository`);
         }
     }
-}
 
-async function cloneRepo(url: string, destination: string) {
-    try {
-        await runCommand(`git clone -q ${url} ${destination}`, { quiet: true });
-    } catch {
-        return false;
-    }
-    fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
-    fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
-    fs.rmSync(path.join(destination, 'package-lock.json'));
-    return true;
-}
+    async cloneRepo(destination: string) {
+        const ok = await gitCloneRepo({ destination, name: REPO_NAME });
+        if (!ok) {
+            return false;
+        }
 
-function isReachable(url: string) {
-    try {
-        runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
-    } catch {
-        return false;
+        fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
+        fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
+        fs.rmSync(path.join(destination, 'package-lock.json'));
+        return true;
     }
-    return true;
 }

package/src/cli/commands/install.ts

@@ -1,12 +1,21 @@
 import { execSync } from 'child_process';
-import { log, logErrors, getStartupVersion } from '../../utils';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log, logErrors, getStartupVersion, readJsonSafe } from '../../utils';
 import { Command } from './types';
+import { gitCloneRepo, isCI } from '../utils';
 
 interface Args {
     quiet?: boolean;
     fix?: 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 implements Command {
     constructor(private readonly args?: Args) {}
 
@@ -16,12 +25,92 @@ export class Install implements Command {
 
     @logErrors
     async execute() {
+        if (!this.args?.quiet) {
+            log.info(`startup cli v${getStartupVersion()}`);
+        }
+
+        const env = await this.configureNpmToken();
+        this.installPackages(env);
+
+        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 ...');
+        }
+
+        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(`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 = [
-            process.env.CI ? 'ci' : 'i',
+            isCI() ? 'ci' : 'i',
             '--audit=false',
             '--fund=false',
             '--legacy-peer-deps',
@@ -29,12 +118,12 @@ export class Install implements Command {
         ].join(' ');
 
         if (!this.args?.quiet) {
-            log.info(`startup cli v${getStartupVersion()}`);
             log.info(`Running npm ${npmArguments} ...`);
         }
 
-        execSync(`npm ${npmArguments}`, { stdio: 'inherit' });
-
-        return Promise.resolve(); // stops "async method has no 'await' expression" lint error
+        execSync(`npm ${npmArguments}`, {
+            ...(env ? { env: { ...process.env, ...env } } : {}),
+            stdio: 'inherit',
+        });
     }
 }

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

@@ -1,7 +1,5 @@
-import { isWebComponent, log, logErrors, readJson } from '../../utils';
-import { getBranchesConfigs } from '../../utils/get-branch-configs';
-import { gitGetBranch } from '../utils/cli-git';
-import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../utils/cli-npm';
+import { getBranchesConfigs, isWebComponent, log, logErrors, readJson } from '../../utils';
+import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../utils';
 import { Command } from './types';
 
 export interface Args {

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

@@ -1,12 +1,24 @@
 import path from 'path';
 import fs from 'fs';
-import { getFolders, isWebComponent, log, logErrors, readJson } from '../../utils';
-import { getBranchesConfigs } from '../../utils/get-branch-configs';
+import {
+    getBranchesConfigs,
+    getFolders,
+    isWebComponent,
+    log,
+    logErrors,
+    readJson,
+} from '../../utils';
 import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
-import { gitGetBranch, gitGetCommitHash } from '../utils/cli-git';
-import { npmGetPackageVersions, npmPackageSet, npmPublish, npmTagVersion } from '../utils/cli-npm';
-import { runCommand } from '../utils/cli-os';
-import { getDefaultBuildVersion } from '../utils/publish';
+import {
+    getDefaultBuildVersion,
+    gitGetBranch,
+    gitGetCommitHash,
+    npmGetPackageVersions,
+    npmPackageSet,
+    npmPublish,
+    npmTagVersion,
+    runCommand,
+} from '../utils';
 import { Command } from './types';
 
 export interface Args {

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

@@ -1,8 +1,8 @@
 import path from 'path';
 import { execSync } from 'child_process';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
+import { isCI, TSConfig } from '../utils';
 import { Command } from './types';
-import { TSConfig } from '../utils';
 
 interface Args {
     dry?: boolean;
@@ -35,7 +35,7 @@ export class UploadSourcemaps implements Command {
     private checkArgs() {
         if (!process.env.DATADOG_API_KEY) {
             const message = 'DATADOG_API_KEY environment variable is not set';
-            if (!process.env.CI) {
+            if (!isCI()) {
                 throw new Error(message);
             }
             log.warning(`${message}; skipping sourcemaps`);

package/src/cli/index.ts

@@ -3,8 +3,7 @@ import path from 'path';
 import { argv, Arguments } from 'yargs';
 import { CommandName, getStartupVersion, log } from '../utils';
 import { getCommand, getUserCommands } from './commands';
-import { setNodeOptions } from './utils';
-import { maybeCreateGitFolder } from './utils/maybe-create-git-folder';
+import { maybeCreateGitFolder, setNodeOptions } from './utils';
 
 const argvSync = argv as Arguments;
 const name = argvSync._[0]?.toString() as CommandName;