@servicetitan/startup 39.1.0 → 39.2.0

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

@@ -1,12 +1,11 @@
-import { isCI } from '@servicetitan/install';
 import { execSync } from 'child_process';
 import { vol } from 'memfs';
 import { inspect } from 'node:util';
 import path from 'path';
 import { log } from '../../../utils';
 import { UploadSourcemaps } from '../upload-sourcemaps';
+import { getUnpkgHost } from '../utils';
 
-jest.mock('@servicetitan/install');
 jest.mock('fs', () => require('memfs').fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
 
@@ -14,9 +13,14 @@ jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: { info: jest.fn(), warning: jest.fn() },
 }));
+jest.mock('../utils', () => ({
+    ...jest.requireActual('../utils'),
+    getUnpkgHost: jest.fn(),
+}));
 
 describe(`[startup] ${UploadSourcemaps.name}`, () => {
     const OLD_ENV = process.env;
+    const unpkgHost = 'https://foo.com';
     const packageJSON = { name: '@servicetitan/example-mfe', cli: { 'web-component': true } };
     const tsconfigJSON = { compilerOptions: { outDir: 'dist' } };
     const metadataJSON = { name: `${packageJSON.name}-hash` };
@@ -36,7 +40,7 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
-        jest.mocked(isCI).mockReturnValue(false);
+        jest.mocked(getUnpkgHost).mockReturnValue(unpkgHost);
 
         // eslint-disable-next-line @typescript-eslint/naming-convention
         process.env = { DATADOG_API_KEY: 'datadog-api-key' };
@@ -62,13 +66,23 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
                 path.join(outDir, 'bundle'),
                 `--service=${packageJSON.name.replace('@servicetitan/', '')}`,
                 `--release-version=${args.releaseVersion}`,
-                `--minified-path-prefix=https://unpkg.servicetitan.com/${packageJSON.name}@${args.releaseVersion}/${outDir}/bundle`,
+                `--minified-path-prefix=${unpkgHost}/${packageJSON.name}@${args.releaseVersion}/${outDir}/bundle`,
                 `--project-path=${metadataJSON.name}/`,
             ].join(' '),
             { stdio: 'inherit' }
         );
     });
 
+    describe('with --registry', () => {
+        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+        test('uses host associated with registry', async () => {
+            await subject();
+
+            expect(getUnpkgHost).toHaveBeenCalledWith(args.registry);
+        });
+    });
+
     describe('with "--dry"', () => {
         beforeEach(() => (args.dry = true));
 
@@ -92,18 +106,18 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
     describe('when DATADOG_API_KEY is not set', () => {
         beforeEach(() => delete process.env.DATADOG_API_KEY);
 
-        itThrowsError('DATADOG_API_KEY environment variable is not set');
+        test('logs warning', async () => {
+            await subject();
 
-        describe('when in CI environment', () => {
-            beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
+            expect(log.warning).toHaveBeenCalledWith(
+                'DATADOG_API_KEY environment variable is not set; skipping sourcemaps'
+            );
+        });
 
-            test('logs warning', async () => {
-                await subject();
+        test('does not run datadog-ci', async () => {
+            await subject();
 
-                expect(log.warning).toHaveBeenCalledWith(
-                    'DATADOG_API_KEY environment variable is not set; skipping sourcemaps'
-                );
-            });
+            expect(execSync).not.toHaveBeenCalled();
         });
     });
 

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

@@ -1,8 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { npmWhoAmI } from '@servicetitan/install';
+import { isCI } from '@servicetitan/install';
 import chalk from 'chalk';
 import Table from 'cli-table3';
-import readline from 'readline/promises';
 import {
     formatRelativeDate,
     getPackages,
@@ -11,17 +10,19 @@ import {
     logErrors,
     PackageType,
 } from '../../utils';
-import { isTTY, NPMPackageInfo, npmView, runCommand } from '../utils';
+import { NPMPackageInfo, npmView } from '../utils';
 import type { entry } from './registry/mfe-list';
 import { Command } from './types';
-import { DEFAULT_MFE_REGISTRY } from './utils';
+import { login, PROD_MFE_REGISTRY } from './utils';
 
 const collator = new Intl.Collator();
 
 export class MFEList extends Command<typeof entry> {
     @logErrors
     async execute() {
-        await this.login();
+        if (!isCI()) {
+            await login(this.registry);
+        }
 
         this.packageNames.forEach((name, index) => {
             const info = npmView({ packageName: name, registry: this.registry });
@@ -97,36 +98,6 @@ export class MFEList extends Command<typeof entry> {
         );
     }
 
-    private async ask(question: string) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const answer = await rl.question(question);
-        rl.close();
-        return answer.trim().toLowerCase();
-    }
-
-    private async login() {
-        if (
-            this.registry !== DEFAULT_MFE_REGISTRY ||
-            npmWhoAmI({ registry: this.registry }) !== undefined
-        ) {
-            return;
-        }
-
-        const message = `This machine is not authorized to access ${this.registry}.`;
-        if (!isTTY()) {
-            throw new Error(message);
-        }
-
-        const answer = await this.ask(chalk.bold.cyan(`${message} Authorize? [Y/n] `));
-        if (answer && answer !== 'y') {
-            throw new Error('Not authorized');
-        }
-
-        await runCommand(`npx --yes verdaccio-okta-oauth@latest --registry=${this.registry}`, {
-            quiet: true,
-        });
-    }
-
     private get limit() {
         if (this.args.all) {
             return Number.MAX_SAFE_INTEGER;
@@ -147,6 +118,6 @@ export class MFEList extends Command<typeof entry> {
     }
 
     private get registry() {
-        return this.args.registry ?? DEFAULT_MFE_REGISTRY;
+        return this.args.registry ?? PROD_MFE_REGISTRY;
     }
 }

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

@@ -2,7 +2,7 @@ import { getBranchesConfigs, isWebComponent, log, logErrors, readJson } from '..
 import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../utils';
 import type { entry } from './registry/mfe-package-clean';
 import { Command } from './types';
-import { DEFAULT_MFE_REGISTRY } from './utils';
+import { getMfeRegistry } from './utils';
 
 export class MFEPackageClean extends Command<typeof entry> {
     @logErrors
@@ -80,7 +80,7 @@ export class MFEPackageClean extends Command<typeof entry> {
             branches = [gitGetBranch()];
         }
 
-        const registry = this.args.registry ?? DEFAULT_MFE_REGISTRY;
+        const registry = getMfeRegistry(this.args.registry);
 
         return { count, registry, branches };
     }

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

@@ -23,7 +23,7 @@ import {
 } from '../utils';
 import type { entry } from './registry/mfe-package-publish';
 import { Command } from './types';
-import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
+import { buildRollbackTag, getMfeRegistry, purgeCache } from './utils';
 
 interface PublishData {
     branch: string;
@@ -63,9 +63,9 @@ export class MFEPackagePublish extends Command<typeof entry> {
 
         await this.maybePublishPackage(packageJson, data);
 
-        const { dry, tag } = data;
+        const { dry, registry, tag } = data;
         if (this.args.purgeCache !== false && !dry) {
-            purgeCache({ packageName: packageJson.name, tag });
+            purgeCache({ packageName: packageJson.name, registry, tag });
         }
 
         if (data.uploadSourcemaps) {
@@ -148,10 +148,12 @@ export class MFEPackagePublish extends Command<typeof entry> {
         }
     }
 
-    private uploadSourcemaps({ dry, version }: PublishData) {
-        const options = [...[dry && '--dry'], `--releaseVersion=${version}`].filter(
-            option => !!option
-        ) as string[];
+    private uploadSourcemaps({ dry, registry, version }: PublishData) {
+        const options = [
+            ...[dry && '--dry'],
+            `--releaseVersion=${version}`,
+            `--registry=${registry}`,
+        ].filter(option => !!option) as string[];
 
         runCommand(`npx startup upload-sourcemaps ${options.join(' ')}`);
     }
@@ -163,7 +165,7 @@ export class MFEPackagePublish extends Command<typeof entry> {
 
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         const buildVersion = cli.build || getDefaultBuildVersion(branch, gitGetCommitHash());
-        const registry = cli.registry ?? DEFAULT_MFE_REGISTRY;
+        const registry = getMfeRegistry(cli.registry);
         const tag = cli.tag ?? branchConfig?.publishTag ?? '';
         const uploadSourcemaps = cli.uploadSourcemaps ?? branchConfig?.uploadSourcemaps ?? true;
         const version = '0.0.0-' + buildVersion;

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

@@ -2,7 +2,7 @@ import { log, logErrors, readJson } from '../../utils';
 import { DRY_RUN_PREFIX, npmTagVersion, npmView } from '../utils';
 import type { entry } from './registry/mfe-package-rollback';
 import { Command } from './types';
-import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
+import { buildRollbackTag, getMfeRegistry, purgeCache } from './utils';
 
 interface PackageJson {
     name: string;
@@ -20,15 +20,16 @@ export class MFEPackageRollback extends Command<typeof entry> {
             log.warning('DRY-RUN MODE ENABLED, WILL NOT PERFORM ROLLBACK');
         }
 
-        const packageName = await this.handleRollback();
+        const registry = getMfeRegistry(this.args.registry);
+        const packageName = await this.handleRollback(registry);
 
         if (packageName && this.args.purgeCache !== false && !dry) {
-            purgeCache({ packageName, tag });
+            purgeCache({ packageName, registry, tag });
         }
     }
 
-    private async handleRollback() {
-        const { tag, registry = DEFAULT_MFE_REGISTRY, dry } = this.args;
+    private async handleRollback(registry: string) {
+        const { tag, dry } = this.args;
 
         const packageJson = readJson<PackageJson>('package.json');
         const packageName = packageJson.name;

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

@@ -1,3 +1,4 @@
+import { isCI } from '@servicetitan/install';
 import { getPackages, isWebComponent, logErrors, PackageType } from '../../utils';
 import { lernaExec } from '../utils';
 import { entry as mfePackageClean } from './registry/mfe-package-clean';
@@ -5,6 +6,7 @@ import { entry as mfePackagePublish } from './registry/mfe-package-publish';
 import { entry as mfePackageRollback } from './registry/mfe-package-rollback';
 import type { entry } from './registry/mfe-publish';
 import { Command } from './types';
+import { getMfeRegistry, login } from './utils';
 
 type MFEPublishOptions = (typeof entry)['options'] &
     (typeof mfePackagePublish)['options'] &
@@ -25,6 +27,10 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
             throw new Error('no packages found for publication');
         }
 
+        if (!isCI()) {
+            await login(this.registry);
+        }
+
         const isRollback = !!this.args.rollback;
         const isClean = !!this.args.clean;
 
@@ -48,26 +54,21 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
         });
     }
 
+    private get registry() {
+        return getMfeRegistry(this.args.registry);
+    }
+
     getPublishOptions() {
-        const {
-            build,
-            branch,
-            dry,
-            force,
-            purgeCache,
-            registry,
-            tag,
-            uploadSourcemaps,
-            trackHistory,
-        } = this.args;
+        const { build, branch, dry, force, purgeCache, tag, uploadSourcemaps, trackHistory } =
+            this.args;
         return [
+            `--registry ${this.registry}`,
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
             ...[purgeCache === true && '--purge-cache'],
             ...[purgeCache === false && '--no-purge-cache'],
-            ...[registry && `--registry ${registry}`],
             ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[trackHistory === true && '--track-history'],
             ...[trackHistory === false && '--no-track-history'],
@@ -77,22 +78,22 @@ export class MFEPublish extends Command<{ options: MFEPublishOptions }> {
     }
 
     getRollbackOptions() {
-        const { dry, registry, tag } = this.args;
+        const { dry, tag } = this.args;
         return [
+            `--registry ${this.registry}`,
             ...[dry && '--dry'],
-            ...[registry && `--registry ${registry}`],
             ...[typeof tag === 'string' && `--tag ${tag}`],
         ].filter(item => !!item) as string[];
     }
 
     getCleanOptions() {
-        const { all, branch, count, dry, registry } = this.args;
+        const { all, branch, count, dry } = this.args;
         return [
+            `--registry ${this.registry}`,
             ...[all && '--all'],
             ...[typeof branch === 'string' && `--branch ${branch}`],
             ...[count && `--count ${count}`],
             ...[dry && '--dry'],
-            ...[registry && `--registry ${registry}`],
         ].filter(item => !!item) as string[];
     }
 }

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

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { PROD_MFE_REGISTRY } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -19,7 +20,11 @@ export const entry = defineEntry({
             description: 'List only the specified number of published versions',
         },
         packageNames: { array: true, string: true, hidden: true },
-        registry: { string: true, hidden: true },
+        registry: {
+            string: true,
+            description: 'List packages published to the specified registry',
+            defaultDescription: PROD_MFE_REGISTRY,
+        },
         tagged: { boolean: true, description: 'List only tagged versions' },
     },
 } satisfies CommandEntry);

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

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -22,6 +23,11 @@ export const entry = defineEntry({
             boolean: true,
             description: 'Take no action and only log what would be unpublished',
         },
-        registry: { string: true, hidden: true, description: 'Registry url' },
+        registry: {
+            string: true,
+            hidden: false,
+            description: 'Registry to remove old versions from',
+            defaultDescription: getMfeRegistry(),
+        },
     },
 } satisfies CommandEntry);

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

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -21,7 +22,12 @@ export const entry = defineEntry({
             boolean: true,
             description: 'Force publishing from an unrecognized branch',
         },
-        registry: { string: true, hidden: true, description: 'Registry url' },
+        registry: {
+            string: true,
+            hidden: false,
+            description: 'Registry to publish to',
+            defaultDescription: getMfeRegistry(),
+        },
         trackHistory: {
             boolean: true,
             description: 'Tag the previous release, to support rollbacks',

package/src/cli/commands/registry/mfe-package-rollback.ts

@@ -1,4 +1,5 @@
 import type { CommandEntry } from '../types';
+import { getMfeRegistry } from '../utils/get-mfe-registry';
 import { defineEntry } from './define-entry';
 
 export const entry = defineEntry({
@@ -9,8 +10,9 @@ export const entry = defineEntry({
         },
         registry: {
             string: true,
-            hidden: true,
-            description: 'Registry url',
+            hidden: false,
+            description: 'Registry to roll back within',
+            defaultDescription: getMfeRegistry(),
         },
         tag: {
             string: true,

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

@@ -4,6 +4,7 @@ import { defineEntry } from './define-entry';
 export const entry = defineEntry({
     options: {
         dry: { boolean: true, description: 'Dry run mode' },
+        registry: { string: true, hidden: true, description: 'Registry url' },
         releaseVersion: {
             string: true,
             demandOption: true,

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

@@ -1,10 +1,10 @@
-import { isCI } from '@servicetitan/install';
 import { execSync } from 'child_process';
 import path from 'path';
 import { getTsConfig, isWebComponent, log, logErrors, readJson } from '../../utils';
 import { TSConfig } from '../utils';
 import type { entry } from './registry/upload-sourcemaps';
 import { Command } from './types';
+import { getUnpkgHost } from './utils';
 
 interface PackageJson {
     name: string;
@@ -29,11 +29,7 @@ export class UploadSourcemaps extends Command<typeof entry> {
 
     private checkArgs() {
         if (!process.env.DATADOG_API_KEY) {
-            const message = 'DATADOG_API_KEY environment variable is not set';
-            if (!isCI()) {
-                throw new Error(message);
-            }
-            log.warning(`${message}; skipping sourcemaps`);
+            log.warning('DATADOG_API_KEY environment variable is not set; skipping sourcemaps');
             return false;
         }
 
@@ -52,7 +48,8 @@ export class UploadSourcemaps extends Command<typeof entry> {
 
     private getMinifiedPrefixPath() {
         const { name } = this.getPackageJson();
-        const baseUrl = `https://unpkg.servicetitan.com/${name}@${this.args.releaseVersion}`;
+        const host = getUnpkgHost(this.args.registry);
+        const baseUrl = `${host}/${name}@${this.args.releaseVersion}`;
         return `${baseUrl}/${this.getBundleDir().replace(/\\/g, '/')}`;
     }
 

package/src/cli/commands/utils/__tests__/get-mfe-registry.test.ts

@@ -0,0 +1,24 @@
+import { PROD_MFE_REGISTRY, getMfeRegistry } from '../get-mfe-registry';
+
+describe(`[startup] ${getMfeRegistry.name}`, () => {
+    let registry: string | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        registry = undefined;
+    });
+
+    const subject = () => getMfeRegistry(registry);
+
+    test('returns the production registry', () => {
+        expect(subject()).toBe(PROD_MFE_REGISTRY);
+    });
+
+    describe('with an explicit registry', () => {
+        beforeEach(() => (registry = 'https://foo.com'));
+
+        test('returns the specified registry', () => {
+            expect(subject()).toBe(registry);
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/get-unpkg-host.test.ts

@@ -0,0 +1,32 @@
+import { DEV_MFE_REGISTRY, getMfeRegistry, PROD_MFE_REGISTRY } from '../get-mfe-registry';
+import { getUnpkgHost } from '../get-unpkg-host';
+
+jest.mock('../get-mfe-registry', () => ({
+    ...jest.requireActual('../get-mfe-registry'),
+    getMfeRegistry: jest.fn(),
+}));
+
+describe(`[startup] ${getUnpkgHost.name}`, () => {
+    const registry = 'http://foo.com';
+
+    const subject = () => getUnpkgHost(registry);
+
+    test('fetches MFE registry', () => {
+        subject();
+
+        expect(getMfeRegistry).toHaveBeenCalledWith(registry);
+    });
+
+    describe.each([
+        [DEV_MFE_REGISTRY, 'https://unpkg.st.dev'],
+        [PROD_MFE_REGISTRY, 'https://unpkg.servicetitan.com'],
+    ])('when the MFE registry is %s', (mfeRegistry, expected) => {
+        beforeEach(() => {
+            jest.mocked(getMfeRegistry).mockImplementation(() => mfeRegistry);
+        });
+
+        test(`returns ${expected}`, () => {
+            expect(subject()).toBe(expected);
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/login.test.ts

@@ -0,0 +1,122 @@
+import { npmWhoAmI } from '@servicetitan/install';
+import { createInterface } from 'readline/promises';
+import { isTTY, runCommand } from '../../../utils';
+import { DEV_MFE_REGISTRY, PROD_MFE_REGISTRY } from '../get-mfe-registry';
+import { login } from '../login';
+
+jest.mock('@servicetitan/install');
+jest.mock('readline/promises', () => ({ createInterface: jest.fn() }));
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    isTTY: jest.fn(),
+    runCommand: jest.fn(),
+}));
+
+describe(`[startup] ${login.name}`, () => {
+    const readline = { question: jest.fn(), close: jest.fn() };
+    let answer: string;
+    let registry: string;
+    let user: string | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        answer = 'Y';
+        registry = PROD_MFE_REGISTRY;
+        user = undefined;
+        jest.mocked(readline.question).mockImplementation(() => Promise.resolve(answer));
+        jest.mocked(createInterface).mockReturnValue(readline as any);
+        jest.mocked(npmWhoAmI).mockImplementation(() => user);
+        jest.mocked(isTTY).mockReturnValue(true);
+    });
+
+    const subject = () => login(registry);
+
+    test('prompts to authorize the machine', async () => {
+        await subject();
+
+        expect(readline.question).toHaveBeenCalledWith(
+            expect.stringMatching(/machine is not authorized.*Authorize\? \[Y\/n\]/)
+        );
+    });
+
+    test('closes the prompt', async () => {
+        await subject();
+
+        expect(readline.close).toHaveBeenCalled();
+    });
+
+    function itAuthorizesTheMachine() {
+        test('authorizes the machine against the registry', async () => {
+            await subject();
+
+            expect(runCommand).toHaveBeenCalledWith(
+                `npx --yes verdaccio-okta-oauth@latest --registry=${registry}`,
+                { quiet: true }
+            );
+        });
+    }
+
+    itAuthorizesTheMachine();
+
+    describe('when user does not answer', () => {
+        beforeEach(() => (answer = ''));
+
+        itAuthorizesTheMachine();
+    });
+
+    describe('when user declines', () => {
+        beforeEach(() => (answer = 'n'));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/Not authorized/);
+        });
+    });
+
+    describe('when terminal is not interactive', () => {
+        beforeEach(() => jest.mocked(isTTY).mockReturnValue(false));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/machine is not authorized/);
+        });
+    });
+
+    function itSkipsPrompt() {
+        test('skips the prompt', async () => {
+            await subject();
+
+            expect(readline.question).not.toHaveBeenCalled();
+        });
+    }
+
+    describe('when machine is already authorized', () => {
+        beforeEach(() => (user = 'someone'));
+
+        itSkipsPrompt();
+    });
+
+    describe(`when the registry is ${DEV_MFE_REGISTRY}`, () => {
+        beforeEach(() => (registry = DEV_MFE_REGISTRY));
+
+        itAuthorizesTheMachine();
+    });
+
+    describe('with an unrecognized registry', () => {
+        beforeEach(() => (registry = 'https://foo.com'));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(/is not recognized/);
+        });
+
+        test('does not attempt oauth', async () => {
+            await expect(subject()).rejects.toThrow();
+
+            expect(runCommand).not.toHaveBeenCalled();
+        });
+
+        describe('when machine is already authorized', () => {
+            beforeEach(() => (user = 'someone'));
+
+            itSkipsPrompt();
+        });
+    });
+});