@servicetitan/startup 31.6.0 → 32.0.1

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;

package/src/cli/utils/__tests__/cli-git.test.ts

@@ -1,11 +1,16 @@
-import { runCommandOutput } from '../cli-os';
+import { runCommand, runCommandOutput } from '../cli-os';
 
-import { gitGetBranch, gitGetCommitHash } from '../cli-git';
+import { gitCloneRepo, gitGetBranch, gitGetCommitHash, gitIsReachable } from '../cli-git';
+import { isCI } from '../is-ci';
 
-jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
+jest.mock('../cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
 
 describe('[startup] Cli Utils (Git)', () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
+    });
 
     function itRunsCommand(subject: Function, command: string) {
         test(`runs "${command}"`, () => {
@@ -18,11 +23,142 @@ describe('[startup] Cli Utils (Git)', () => {
         });
     }
 
-    describe(`${gitGetBranch.name}`, () => {
+    describe(gitGetBranch.name, () => {
         itRunsCommand(gitGetBranch, 'git rev-parse --abbrev-ref HEAD');
     });
 
-    describe(`${gitGetCommitHash.name}`, () => {
+    describe(gitGetCommitHash.name, () => {
         itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
     });
+
+    describe(gitCloneRepo.name, () => {
+        const destination = 'foo';
+        const name = '{name}';
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        let params: Parameters<typeof gitCloneRepo>[0];
+
+        beforeEach(() => (params = { destination, name }));
+
+        const subject = () => gitCloneRepo(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, async () => {
+                expect(await subject()).toBe(value);
+            });
+        }
+
+        test(`clones ${webUrl} to destination directory`, async () => {
+            await subject();
+
+            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when cloning ${webUrl} fails`, () => {
+            beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
+
+            test(`clones ${sshUrl} to destination directory`, async () => {
+                await subject();
+
+                expect(runCommand).toHaveBeenCalledWith(
+                    `git clone -q ${sshUrl} ${destination}`,
+                    expect.anything()
+                );
+            });
+
+            itReturns(true);
+
+            describe(`when cloning ${sshUrl} also fails`, () => {
+                beforeEach(() => {
+                    jest.mocked(runCommand).mockRejectedValue('Nope!');
+                });
+
+                itReturns(false);
+            });
+        });
+
+        describe('when running in CI environment with GITHUB_TOKEN', () => {
+            const originalEnv = process.env;
+            const token = 'foo-bar';
+
+            beforeEach(() => {
+                jest.mocked(isCI).mockReturnValue(true);
+                process.env.GITHUB_TOKEN = token;
+            });
+            afterEach(() => (process.env = originalEnv));
+
+            test(`adds token to ${webUrl}`, async () => {
+                await subject();
+
+                const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
+                expect(runCommand).toHaveBeenCalledWith(
+                    `git clone -q ${urlWithToken} ${destination}`,
+                    expect.anything()
+                );
+            });
+        });
+    });
+
+    describe(gitIsReachable.name, () => {
+        const name = '{name}';
+
+        let params: Parameters<typeof gitIsReachable>[0];
+
+        beforeEach(() => (params = { name }));
+
+        const subject = () => gitIsReachable(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, () => {
+                expect(subject()).toBe(value);
+            });
+        }
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        test(`checks if ${webUrl} is reachable`, () => {
+            subject();
+
+            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when ${webUrl} is not reachable`, () => {
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementationOnce(() => {
+                    throw new Error('Oops!');
+                });
+            });
+
+            test(`checks if ${sshUrl} is reachable`, () => {
+                subject();
+
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                    quiet: true,
+                });
+            });
+
+            itReturns(true);
+
+            describe(`when ${sshUrl} is also unreachable`, () => {
+                beforeEach(() =>
+                    jest.mocked(runCommandOutput).mockImplementation(() => {
+                        throw new Error('Oops');
+                    })
+                );
+
+                itReturns(false);
+            });
+        });
+    });
 });

package/src/cli/utils/__tests__/eslint.test.ts

@@ -1,12 +1,13 @@
 import { fs, vol } from 'memfs';
 import { ESLint } from 'eslint';
 
+import { getDestinationFolders } from '../../../utils';
 import { eslint } from '../eslint';
-import { getDestinationFolders } from '../../../utils/get-destination-folders';
 
 jest.mock('fs', () => fs);
 jest.mock('eslint');
-jest.mock('../../../utils/get-destination-folders', () => ({
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getDestinationFolders: jest.fn(),
 }));
 

package/src/cli/utils/__tests__/is-ci.test.ts

@@ -0,0 +1,40 @@
+import { isCI } from '../is-ci';
+
+describe(`[startup] Utils ${isCI.name}`, () => {
+    const originalCI = process.env.CI;
+
+    beforeAll(() => delete process.env.CI);
+    afterAll(() => (process.env.CI = originalCI));
+
+    const subject = () => isCI();
+
+    function itReturns(value: boolean) {
+        test(`returns ${value}`, () => {
+            expect(subject()).toBe(value);
+        });
+    }
+
+    itReturns(false);
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.CI is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.CI = value));
+
+        afterEach(() => delete process.env.CI);
+
+        itReturns(result);
+    });
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.TEAMCITY_VERSION is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.TEAMCITY_VERSION = value));
+
+        afterEach(() => delete process.env.TEAMCITY_VERSION);
+
+        itReturns(result);
+    });
+});

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -1,9 +1,11 @@
 import execa from 'execa';
 
 import { log } from '../../../utils';
+import { isCI } from '../is-ci';
 import { lernaExec } from '../lerna-exec';
 
 jest.mock('execa');
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
 
 const AVAILABLE_PARALLELISM = 2;
 
@@ -17,9 +19,9 @@ describe(`${lernaExec.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
         args = { cmd: 'foo' };
-        delete process.env.CI;
     });
 
     const subject = () => lernaExec(args);
@@ -60,10 +62,11 @@ describe(`${lernaExec.name}`, () => {
         itRunsLernaExec(option);
     });
 
-    describe('when process.env.CI=true', () => {
+    describe('when in CI environment', () => {
         beforeEach(() => {
-            process.env.CI = 'true';
+            jest.mocked(isCI).mockReturnValue(true);
         });
+
         describe.each([
             { arg: { parallel: true }, option: `--concurrency=${AVAILABLE_PARALLELISM}` },
             { arg: { parallel: 10 }, option: '--concurrency=10' },

package/src/cli/utils/cli-git.ts

@@ -1,9 +1,59 @@
-import { runCommandOutput } from './cli-os';
+import { log } from '../../utils';
+import { runCommand, runCommandOutput } from './cli-os';
+import { isCI } from './is-ci';
 
-export const gitGetBranch = (): string => {
+export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
-};
+}
 
-export const gitGetCommitHash = (): string => {
+export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
-};
+}
+
+interface Repo {
+    owner?: string;
+    name: string;
+}
+
+export async function gitCloneRepo(params: Repo & { destination: string }) {
+    const { destination, name, owner = 'servicetitan' } = params;
+    const gitUrls = getGitUrls({ owner, name });
+
+    for (const url of gitUrls) {
+        try {
+            const command = `git clone -q ${url} ${destination}`;
+            log.debug('git:clone-repo', `running ${command}`);
+
+            // eslint-disable-next-line no-await-in-loop
+            await runCommand(command, { quiet: true });
+            return true;
+        } catch {
+            // ignore error
+        }
+    }
+
+    return false;
+}
+
+export function gitIsReachable({ owner = 'servicetitan', name }: Repo) {
+    return getGitUrls({ owner, name }).some(url => {
+        try {
+            runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
+            return true;
+        } catch {
+            return false;
+        }
+    });
+}
+
+function getGitUrls({ owner, name }: Repo) {
+    const webUrl = `https://github.com/${owner}/${name}.git`;
+    const sshUrl = `git@github.com:${owner}/${name}.git`;
+
+    const urls = [webUrl, sshUrl];
+    if (isCI() && !!process.env.GITHUB_TOKEN) {
+        urls.unshift(webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`));
+    }
+
+    return urls;
+}

package/src/cli/utils/cli-os.ts

@@ -42,7 +42,7 @@ export const runCommand = (
         proc.stdout.pipe(process.stdout);
         proc.stderr.pipe(process.stderr);
 
-        proc.on('exit', function (code: any) {
+        proc.on('exit', function (code) {
             if (!quiet) {
                 log.info(`command finished with code ${code}`, fullCommand);
             }
@@ -53,6 +53,9 @@ export const runCommand = (
                 resolve();
             }
         });
+        proc.on('error', function (e) {
+            reject(e);
+        });
     });
 };
 

package/src/cli/utils/index.ts

@@ -1,15 +1,21 @@
 export * from './bundle';
 export * from './check-args';
+export * from './cli-git';
+export * from './cli-npm';
+export * from './cli-os';
 export * from './compile';
 export * from './compile-less';
 export * from './compile-sass';
 export * from './copy-files';
 export * from './eslint';
 export * from './get-module-type';
+export * from './is-ci';
 export * from './is-module-installed';
 export * from './lerna-exec';
+export * from './maybe-create-git-folder';
 export * from './pipe-stdout';
 export * from './process-tree';
+export * from './publish';
 export * from './set-node-options';
 export * from './ts-config';
 export * from './type-check';

package/src/cli/utils/is-ci.ts

@@ -0,0 +1,3 @@
+export function isCI() {
+    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;
+}

package/src/cli/utils/lerna-exec.ts

@@ -2,6 +2,7 @@ import execa, { StdioOption } from 'execa';
 import os from 'node:os';
 
 import { log } from '../../utils';
+import { isCI } from './is-ci';
 
 interface Args {
     'bail'?: boolean;
@@ -37,7 +38,7 @@ function getOptions(args: Args) {
         result.push('--no-bail');
     }
     if (args.parallel === true) {
-        result.push(process.env.CI ? `--concurrency=${os.availableParallelism()}` : '--parallel');
+        result.push(isCI() ? `--concurrency=${os.availableParallelism()}` : '--parallel');
     } else if (typeof args.parallel === 'number') {
         result.push(`--concurrency=${args.parallel}`);
     }

package/src/utils/get-branch-configs.ts

@@ -1,4 +1,4 @@
-import { getWebComponentBranchConfigs, WebComponentBranchConfigs } from './index';
+import { getWebComponentBranchConfigs, WebComponentBranchConfigs } from './get-configuration';
 
 function getDefaultConfigs(): Record<string, WebComponentBranchConfigs> {
     return {

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from './find-packages';
 export * from './find-up';
 export * from './format-duration';
+export * from './get-branch-configs';
 export * from './get-configuration';
 export * from './get-destination-folders';
 export * from './get-folders';