@servicetitan/startup 39.1.0 → 39.3.0

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();
+        });
+    });
+});

package/src/cli/commands/utils/__tests__/purge-cache.test.ts

@@ -1,40 +1,42 @@
 import { runCommandOutput } from '../../../utils';
+import { getUnpkgHost } from '../get-unpkg-host';
 import { purgeCache } from '../purge-cache';
 
+jest.mock('@servicetitan/install', () => ({ isCI: jest.fn() }));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     runCommandOutput: jest.fn(),
 }));
+jest.mock('../get-unpkg-host', () => ({
+    getUnpkgHost: jest.fn(),
+}));
 
 describe(purgeCache.name, () => {
-    let args: Parameters<typeof purgeCache>[0];
+    const unpkgHost = 'https://foo.com';
     const packageName = '@servicetitan/foo';
+    const registry = 'https://bar.com';
     const tag = 'prod';
+    let args: Parameters<typeof purgeCache>[0];
 
     beforeEach(() => {
         jest.clearAllMocks();
-        args = { packageName, tag };
+        jest.mocked(getUnpkgHost).mockReturnValue(unpkgHost);
+        args = { packageName, registry, tag };
     });
 
     const subject = () => purgeCache(args);
 
-    test('runs mfe-purge-cache with host "https://unpkg.servicetitan.com", package name and tag', () => {
+    test('fetches host for registry', () => {
         subject();
 
-        expect(runCommandOutput).toHaveBeenCalledWith(
-            `npx startup mfe-purge-cache --host https://unpkg.servicetitan.com --package-name ${packageName} --tag ${tag}`
-        );
+        expect(getUnpkgHost).toHaveBeenCalledWith(registry);
     });
 
-    describe('when registry is "https://verdaccio.st.dev"', () => {
-        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
-
-        test('runs mfe-purge-cache with host "https://unpkg.st.dev"', () => {
-            subject();
+    test('runs mfe-purge-cache', () => {
+        subject();
 
-            expect(runCommandOutput).toHaveBeenCalledWith(
-                expect.stringContaining(`--host https://unpkg.st.dev`)
-            );
-        });
+        expect(runCommandOutput).toHaveBeenCalledWith(
+            `npx startup mfe-purge-cache --host ${unpkgHost} --package-name ${packageName} --tag ${tag}`
+        );
     });
 });

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

@@ -0,0 +1,6 @@
+export const PROD_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
+export const DEV_MFE_REGISTRY = 'https://verdaccio.st.dev';
+
+export function getMfeRegistry(registry?: string): string {
+    return registry ?? PROD_MFE_REGISTRY;
+}

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

@@ -0,0 +1,8 @@
+import { DEV_MFE_REGISTRY, getMfeRegistry } from './get-mfe-registry';
+
+const PROD_UNPKG_HOST = 'https://unpkg.servicetitan.com';
+const DEV_UNPKG_HOST = 'https://unpkg.st.dev';
+
+export function getUnpkgHost(registry?: string): string {
+    return getMfeRegistry(registry) === DEV_MFE_REGISTRY ? DEV_UNPKG_HOST : PROD_UNPKG_HOST;
+}

package/src/cli/commands/utils/index.ts

@@ -1,3 +1,5 @@
 export * from './build-rollback-tag';
-export * from './constants';
+export * from './get-mfe-registry';
+export * from './get-unpkg-host';
+export * from './login';
 export * from './purge-cache';

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

@@ -0,0 +1,38 @@
+import { npmWhoAmI } from '@servicetitan/install';
+import chalk from 'chalk';
+import readline from 'readline/promises';
+import { isTTY, runCommand } from '../../utils';
+import { DEV_MFE_REGISTRY, PROD_MFE_REGISTRY } from './get-mfe-registry';
+
+const OKTA_REGISTRIES: string[] = [PROD_MFE_REGISTRY, DEV_MFE_REGISTRY];
+
+export async function login(registry: string) {
+    if (npmWhoAmI({ registry }) !== undefined) {
+        return;
+    }
+
+    if (!OKTA_REGISTRIES.includes(registry)) {
+        throw new Error(`Registry ${registry} is not recognized. Please log in manually.`);
+    }
+
+    const message = `This machine is not authorized to access ${registry}.`;
+    if (!isTTY()) {
+        throw new Error(message);
+    }
+
+    const answer = await 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=${registry}`, {
+        quiet: true,
+    });
+}
+
+async function 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();
+}

package/src/cli/commands/utils/purge-cache.ts

@@ -1,12 +1,9 @@
 import { runCommandOutput } from '../../utils';
-
-const DEV_MFE_REGISTRY = 'https://verdaccio.st.dev';
-const DEFAULT_UNPKG_HOST = 'https://unpkg.servicetitan.com';
-const DEV_UNPKG_HOST = 'https://unpkg.st.dev';
+import { getUnpkgHost } from './get-unpkg-host';
 
 export function purgeCache(options: { packageName: string; registry?: string; tag: string }) {
     const { packageName, registry, tag } = options;
-    const host = registry === DEV_MFE_REGISTRY ? DEV_UNPKG_HOST : DEFAULT_UNPKG_HOST;
+    const host = getUnpkgHost(registry);
     runCommandOutput(
         `npx startup mfe-purge-cache --host ${host} --package-name ${packageName} --tag ${tag}`
     );

package/src/cli/index.ts

@@ -40,7 +40,8 @@ function addCommand(name: CommandName, y: typeof yargs) {
     const { description, options: { _, ...options } = {} } = entry;
     const nameWithArgs = name + (_?.description ? ` ${_.description}` : '');
     const groupedOptions = Object.entries(options).reduce((result, [key, value]) => {
-        result[kebabCase(key)] = { group: 'Command Options:', ...value };
+        const suffix = /\W+$/.exec(key)?.[0] ?? ''; // fix for kebabCase dropping `\u00A0` suffixes
+        result[kebabCase(key) + suffix] = { group: 'Command Options:', ...value };
         return result;
     }, {} as CommandOptions);
     const handler = (argv: any) => handleCommand(name, argv);

package/src/vite/config/__tests__/create-resolve-config.test.ts

@@ -1,9 +1,5 @@
 import { createRequire } from 'module';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { buildEscapedRegExp } from '../../build-escaped-reg-exp';
-import { ViteBuildContext } from '../../types';
 import { createResolveConfig } from '../create-resolve-config';
 
 jest.mock('module', () => ({
@@ -13,7 +9,6 @@ jest.mock('module', () => ({
 
 describe(`[startup] ${createResolveConfig.name}`, () => {
     let startupRequire: { resolve: (specifier: string) => string };
-    let context: Partial<ViteBuildContext>;
     let specifiers: string[];
 
     beforeAll(() => {
@@ -25,23 +20,11 @@ describe(`[startup] ${createResolveConfig.name}`, () => {
         jest.mocked(startupRequire.resolve).mockImplementation(() => {
             throw new Error('Module not found');
         });
-        const source = fs.mkdtempSync(path.join(os.tmpdir(), 'create-resolve-config-'));
-        context = { package: { source } as any };
         specifiers = ['a', '@b/c'];
     });
 
-    afterEach(() => fs.rmSync(context.package!.source, { recursive: true, force: true }));
-
-    function mockNodeModules(root: string, modules: string[]) {
-        modules.forEach(name => {
-            const dir = path.join(root, 'node_modules', ...name.split('/'));
-            fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(path.join(dir, 'index.js'), '');
-        });
-    }
-
     const subject = () =>
-        createResolveConfig(context as any, specifiers) as {
+        createResolveConfig(specifiers) as {
             alias: { find: RegExp; replacement: string }[];
         };
 
@@ -49,14 +32,6 @@ describe(`[startup] ${createResolveConfig.name}`, () => {
         expect(() => subject()).toThrow(/cannot resolve/i);
     });
 
-    describe('when specifier is resolvable', () => {
-        beforeEach(() => mockNodeModules(context.package!.source, specifiers));
-
-        test('does nothing', () => {
-            expect(subject().alias).toEqual([]);
-        });
-    });
-
     describe('when specifier is resolvable from startup', () => {
         beforeEach(() => {
             jest.mocked(startupRequire.resolve).mockImplementation(
@@ -65,20 +40,14 @@ describe(`[startup] ${createResolveConfig.name}`, () => {
         });
 
         test('emits alias', () => {
-            const { alias } = subject();
-
-            specifiers.forEach(specifier => {
-                expect(alias.find(({ find }) => find.test(specifier))?.replacement).toEqual(
-                    `startup/${specifier}`
-                );
-            });
+            expect(subject().alias.map(({ replacement }) => replacement)).toEqual(
+                specifiers.map(specifier => `startup/${specifier}`)
+            );
         });
 
         test('alias matches whole specifier', () => {
-            const { alias } = subject();
-
-            specifiers.forEach((specifier, i) =>
-                expect(alias[i].find).toEqual(buildEscapedRegExp(specifier))
+            expect(subject().alias.map(({ find }) => find)).toEqual(
+                specifiers.map(specifier => buildEscapedRegExp(specifier))
             );
         });
     });

package/src/vite/config/base-config.ts

@@ -122,7 +122,7 @@ export function createBaseConfig(context: ViteBuildContext): InlineConfig {
             ),
             ...(getProcessEnv(context) ?? {}),
         },
-        resolve: createResolveConfig(context, optimizedStartupDependencies),
+        resolve: createResolveConfig(optimizedStartupDependencies),
         optimizeDeps: {
             include: [
                 ...optimizedStartupDependencies,

package/src/vite/config/create-resolve-config.ts

@@ -1,39 +1,25 @@
 import { createRequire } from 'module';
-import path from 'path';
 import type { InlineConfig } from 'vite';
 import { buildEscapedRegExp } from '../build-escaped-reg-exp';
-import type { ViteBuildContext } from '../types';
 
 type Result = InlineConfig['resolve'];
 
 const startupRequire = createRequire(__filename);
 
 /*
- * Returns a resolver that, when normal resolution fails for a specifier,
- * tries resolving from startup's location.
+ * Returns a resolver that resolves from startup's location. Use only for
+ * startup's internal dependencies that may not be directly resolvable by
+ * consumers using pnpm.
  */
-export function createResolveConfig(context: ViteBuildContext, specifiers: string[]): Result {
-    const source = path.resolve(context.package.source);
-
-    const alias = specifiers
-        .filter(specifier => !isResolvableFrom(specifier, source))
-        .map(specifier => ({
-            find: buildEscapedRegExp(specifier),
-            replacement: resolveFromStartup(specifier),
-        }));
+export function createResolveConfig(specifiers: string[]): Result {
+    const alias = specifiers.map(specifier => ({
+        find: buildEscapedRegExp(specifier),
+        replacement: resolveFromStartup(specifier),
+    }));
 
     return { alias };
 }
 
-function isResolvableFrom(specifier: string, source: string): boolean {
-    try {
-        require.resolve(specifier, { paths: [source] });
-        return true;
-    } catch {
-        return false;
-    }
-}
-
 function resolveFromStartup(specifier: string): string {
     try {
         return startupRequire.resolve(specifier);

package/dist/cli/commands/utils/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const DEFAULT_MFE_REGISTRY = "https://verdaccio.servicetitan.com";
-//# sourceMappingURL=constants.d.ts.map

package/dist/cli/commands/utils/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/utils/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,uCAAuC,CAAC"}

package/dist/cli/commands/utils/constants.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DEFAULT_MFE_REGISTRY", {
-    enumerable: true,
-    get: function() {
-        return DEFAULT_MFE_REGISTRY;
-    }
-});
-const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
-
-//# sourceMappingURL=constants.js.map

package/dist/cli/commands/utils/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/cli/commands/utils/constants.ts"],"sourcesContent":["export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';\n"],"names":["DEFAULT_MFE_REGISTRY"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,uBAAuB"}

package/src/cli/commands/utils/constants.ts

@@ -1 +0,0 @@
-export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';