@servicetitan/startup 32.2.0 → 32.3.0

package/src/cli/utils/__tests__/set-node-options.test.ts

@@ -1,6 +1,6 @@
 import os from 'os';
 import { getConfigurationSafe } from '../../../utils';
-import { Command } from '../../commands';
+import { Command } from '../../commands/types';
 
 import { setNodeOptions } from '../set-node-options';
 
@@ -13,15 +13,11 @@ jest.mock('../../../utils', () => ({
     getConfigurationSafe: jest.fn(() => ({})),
 }));
 
-class MockCommand implements Command {
-    get greedy() {
+class MockCommand extends Command {
+    static get greedy() {
         return true;
     }
 
-    description() {
-        return 'mock command';
-    }
-
     async execute() {
         return Promise.resolve();
     }
@@ -33,12 +29,16 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
     const originalNodeOptions = process.env.NODE_OPTIONS;
     const maxOldSpaceSize = `--max_old_space_size=${DEFAULT_SIZE}`;
     const commandName: any = 'mock';
-    const command = new MockCommand();
+    const command = new MockCommand({});
+    let greedy: boolean;
 
     beforeEach(() => {
+        greedy = true;
         delete process.env.NODE_OPTIONS;
         (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
-        jest.spyOn(command, 'greedy', 'get').mockReturnValue(true);
+        jest.spyOn(command.constructor as typeof Command, 'greedy', 'get').mockImplementation(
+            () => greedy
+        );
     });
 
     afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
@@ -52,7 +52,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
     });
 
     describe('when the command is not greedy', () => {
-        beforeEach(() => jest.spyOn(command, 'greedy', 'get').mockReturnValue(false));
+        beforeEach(() => (greedy = false));
 
         test('returns false and does not set NODE_OPTIONS', () => {
             expect(subject()).toBe(false);

package/src/cli/utils/bundle.ts

@@ -52,7 +52,7 @@ export async function bundle(options: Options = {}) {
 
     log.info(`Bundling ${emitExposedDependencies ? 'exposed dependencies' : 'package'}...`);
 
-    const mode = watch ? 'development' : 'production';
+    const mode = watch || useWatchConfig ? 'development' : 'production';
     const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
     const customConfig = readWebpackConfig({ ...options, fallback });
     const webpackOptions = getWebpackOptions(options, customConfig);

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

@@ -73,3 +73,37 @@ export async function npmTagVersion({
         }add ${packageName}@${packageVersion} ${tag}`
     );
 }
+
+export interface NPMPackageInfo {
+    'name': string;
+    'version': string;
+    'dist-tags'?: Record<string, string>;
+    'time'?: Record<string, string>;
+    'versions'?: string[];
+}
+
+export function npmView({ packageName, registry }: { packageName: string; registry?: string }) {
+    try {
+        const result = runCommandOutput(
+            ['npm', 'view', '--json', registry ? `--registry=${registry}` : '', packageName],
+            { quiet: true, timeout: NPM_TIMEOUT }
+        );
+        if (result) {
+            return JSON.parse(result) as NPMPackageInfo;
+        }
+    } catch {
+        // ignore
+    }
+}
+
+export function npmWhoAmI({ registry }: { registry?: string } = {}) {
+    try {
+        return runCommandOutput(['npm', 'whoami', registry ? `--registry=${registry}` : ''], {
+            quiet: true,
+            stdio: ['pipe', 'pipe', 'ignore'],
+            timeout: NPM_TIMEOUT,
+        }).trim();
+    } catch {
+        // ignore
+    }
+}

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

@@ -8,25 +8,19 @@ import { log } from '../../utils';
 
 type RunCommandOptions = SpawnOptionsWithoutStdio & { quiet?: boolean };
 
-export const runCommand = (
+export async function runCommand(
     command: string | (string | false)[],
     { quiet, ...spawnOptions }: RunCommandOptions = {}
-): Promise<void> => {
-    return new Promise((resolve, reject) => {
+) {
+    return new Promise<void>((resolve, reject) => {
         const commandArray: string[] = Array.isArray(command)
-            ? command
-                  .filter(c => !!c)
-                  .map(c => c.toString())
-                  .join(' ')
-                  .split(' ')
+            ? command.reduce((acc, el) => (el ? [...acc, ...el.toString().split(' ')] : acc), [])
             : command.split(' ');
         const fullCommand = commandArray.join(' ');
-
         const commandName = commandArray.shift();
 
         if (!commandName) {
             reject(new Error('invalid command'));
-
             return;
         }
 
@@ -57,26 +51,19 @@ export const runCommand = (
             reject(e);
         });
     });
-};
+}
 
 type RunCommandOutputOptions = ExecSyncOptionsWithBufferEncoding & { quiet?: boolean };
 
-export const runCommandOutput = (
+export function runCommandOutput(
     command: string | (string | false)[],
     { quiet, ...execSyncOptions }: RunCommandOutputOptions = {}
-): string => {
-    const commandArray: string[] = Array.isArray(command)
-        ? command
-              .filter(c => !!c)
-              .map(c => c.toString())
-              .join(' ')
-              .split(' ')
-        : command.split(' ');
-    const fullCommand = commandArray.join(' ');
-
-    const commandName = commandArray.shift();
+) {
+    const fullCommand = Array.isArray(command)
+        ? command.reduce((acc, el) => (el ? [...acc, el.toString()] : acc), []).join(' ')
+        : command;
 
-    if (!commandName) {
+    if (!fullCommand) {
         throw new Error();
     }
 
@@ -91,4 +78,4 @@ export const runCommandOutput = (
     }
 
     return result;
-};
+}

package/src/cli/utils/eslint.ts

@@ -1,8 +1,9 @@
 import { ESLint } from 'eslint';
 
 import { getDestinationFolders, getESLintConfiguration, log } from '../../utils';
+import { CommandArgs } from '../commands';
 
-interface Args {
+interface Args extends CommandArgs {
     fix?: boolean;
     paths: string[];
 }

package/src/cli/utils/index.ts

@@ -11,6 +11,7 @@ export * from './eslint';
 export * from './get-module-type';
 export * from './is-ci';
 export * from './is-module-installed';
+export * from './is-tty';
 export * from './lerna-exec';
 export * from './maybe-create-git-folder';
 export * from './pipe-stdout';

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

@@ -0,0 +1,3 @@
+export function isTTY() {
+    return process.stdin.isTTY;
+}

package/src/cli/utils/maybe-create-git-folder.ts

@@ -1,21 +1,18 @@
 import fs from 'fs';
-
-import { Init } from '../commands/init';
 import { Command, Newable } from '../commands/types';
 
+const EXCLUDED_COMMANDS = ['Init', 'Install'];
+
 /**
  * Create empty .git folder to workaround issue where Lerna does not
- * detect workspace packages on Windows systems. The empty .git folder
+ * detect workspace packages. The empty .git folder
  * causes nx to use the git-hasher when building the project graph.
  * Note this gets fixed (e.g., https://github.com/nrwl/nx/issues/8601) but
  * keeps reappearing (e.g., https://github.com/nrwl/nx/issues/9584 and
  * https://github.com/nrwl/nx/issues/18094)
  */
 export function maybeCreateGitFolder(command: Newable<Command>) {
-    if (process.platform !== 'win32') {
-        return;
-    }
-    if (command === Init) {
+    if (EXCLUDED_COMMANDS.includes(command.name)) {
         return;
     }
     if (!fs.existsSync('.git')) {

package/src/cli/utils/process-tree.ts

@@ -42,7 +42,7 @@ export class ProcessTree<T extends Record<any, any> = never> {
             const entry = this.#entries.get(item)!;
 
             const handlerResult = Promise.all(
-                entry.dependsOn.map(item => this.#entries.get(item)!.onComplete)
+                entry.dependsOn.map(item => this.#entries.get(item)!.onComplete).filter(el => !!el)
             ).then(() => ({ result: entry.handler() }));
 
             entry.process = handlerResult.then(({ result }) =>
@@ -52,6 +52,8 @@ export class ProcessTree<T extends Record<any, any> = never> {
                 isHandlerResultObject(result) ? (result.onComplete ?? result.process) : result
             );
         });
-        return Promise.all([...this.#entries.values()].map(item => item.process));
+        return Promise.all(
+            [...this.#entries.values()].map(item => item.process).filter(el => !!el)
+        );
     }
 }

package/src/cli/utils/set-node-options.ts

@@ -25,7 +25,8 @@ export function setNodeOptions(commandName: CommandName, command: Command) {
         }, oldNodeOptions)
         .trim();
 
-    const newNodeOptions = ensureMaxOldSpaceSize(mergedOptions, command.greedy);
+    const greedy = (command.constructor as typeof Command).greedy;
+    const newNodeOptions = ensureMaxOldSpaceSize(mergedOptions, greedy);
     if (newNodeOptions !== oldNodeOptions) {
         process.env.NODE_OPTIONS = newNodeOptions;
         return true;

package/src/utils/__tests__/format-relative-date.test.ts

@@ -0,0 +1,61 @@
+import { formatRelativeDate } from '../format-relative-date';
+
+describe('[startup] Utils', () => {
+    describe(formatRelativeDate.name, () => {
+        beforeAll(() => {
+            jest.useFakeTimers();
+            jest.setSystemTime(new Date(2025, 0, 1));
+        });
+        afterAll(() => jest.useRealTimers());
+
+        type DateUnit = 'seconds' | 'minutes' | 'hours' | 'days' | 'months' | 'years';
+
+        function adjustDate(when: Date, amount: number, by: DateUnit) {
+            const result = new Date(when);
+            if (by === 'seconds') {
+                result.setSeconds(when.getSeconds() + amount);
+            } else if (by === 'minutes') {
+                result.setMinutes(when.getMinutes() + amount);
+            } else if (by === 'hours') {
+                result.setHours(when.getHours() + amount);
+            } else if (by === 'days') {
+                result.setDate(when.getDate() + amount);
+            } else if (by === 'months') {
+                result.setMonth(when.getMonth() + amount);
+            } else if (by === 'years') {
+                result.setFullYear(when.getFullYear() + amount);
+            }
+            return result;
+        }
+
+        test.each<{
+            delta: [number, DateUnit];
+            expected: string;
+        }>([
+            { delta: [0, 'seconds'], expected: 'in 0 seconds' },
+            { delta: [1, 'seconds'], expected: 'in 1 second' },
+            { delta: [-2, 'seconds'], expected: '2 seconds ago' },
+            { delta: [1, 'minutes'], expected: 'in 1 minute' },
+            { delta: [-2, 'minutes'], expected: '2 minutes ago' },
+            { delta: [1, 'hours'], expected: 'in 1 hour' },
+            { delta: [-2, 'hours'], expected: '2 hours ago' },
+            { delta: [1, 'days'], expected: 'in 1 day' },
+            { delta: [-2, 'days'], expected: '2 days ago' },
+            { delta: [1, 'months'], expected: 'in 1 month' },
+            { delta: [-2, 'months'], expected: '2 months ago' },
+            { delta: [1, 'years'], expected: 'in 1 year' },
+            { delta: [-2, 'years'], expected: '2 years ago' },
+        ])(
+            `with $delta.0 $delta.1 from now, returns "$expected"`,
+            ({ delta: [amount, unit], expected }) => {
+                const now = new Date();
+                const from = adjustDate(now, amount, unit);
+                expect(formatRelativeDate(from, now)).toBe(expected);
+            }
+        );
+
+        test('with no "to", returns time relative to now', () => {
+            expect(formatRelativeDate(Date.now() - 61 * 1000)).toEqual('1 minute ago');
+        });
+    });
+});

package/src/utils/__tests__/get-packages.test.ts

@@ -73,6 +73,7 @@ describe('[startup] Utils', () => {
                     private: false,
                     location: path.resolve('./legacy/bar'),
                     type: PackageType.Legacy,
+                    cli: { legacy: true },
                 },
                 {
                     name: 'baz',
@@ -80,6 +81,7 @@ describe('[startup] Utils', () => {
                     private: false,
                     location: path.resolve('./examples/baz'),
                     type: PackageType.TSC,
+                    cli: { webpack: false },
                 },
                 {
                     name: 'qux',
@@ -87,6 +89,7 @@ describe('[startup] Utils', () => {
                     private: false,
                     location: path.resolve('./examples/qux'),
                     type: PackageType.TSC,
+                    cli: { webpack: false },
                 },
             ]);
         });

package/src/utils/find-packages.ts

@@ -8,6 +8,7 @@ import { log } from './log';
 export interface ProjectPackage extends Record<string, any> {
     name: string;
     location: string;
+    version: string;
 }
 
 export function findPackages(): ProjectPackage[] {

package/src/utils/format-relative-date.ts

@@ -0,0 +1,33 @@
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = MINUTE * 60;
+const DAY = HOUR * 24;
+const MONTH = DAY * 30;
+const YEAR = DAY * 365;
+
+const table: { threshold: number; divisor: number; unit: Intl.RelativeTimeFormatUnit }[] = [
+    { threshold: MINUTE, divisor: SECOND, unit: 'seconds' },
+    { threshold: HOUR, divisor: MINUTE, unit: 'minutes' },
+    { threshold: DAY, divisor: HOUR, unit: 'hours' },
+    { threshold: MONTH, divisor: DAY, unit: 'days' },
+    { threshold: YEAR, divisor: MONTH, unit: 'months' },
+];
+
+export function formatRelativeDate(
+    from: Date | string | number,
+    to?: Date | string | number,
+    locale?: string
+) {
+    const dateFrom = new Date(from);
+    const dateTo = to ? new Date(to) : new Date();
+    const delta = dateFrom.getTime() - dateTo.getTime();
+    const absoluteDelta = Math.abs(delta);
+    const { divisor, unit } = table.find(({ threshold }) => absoluteDelta < threshold) ?? {
+        divisor: YEAR,
+        unit: 'years',
+    };
+    return new Intl.RelativeTimeFormat(locale, {
+        style: 'long',
+        numeric: 'always',
+    }).format(Math.round(delta / divisor), unit);
+}

package/src/utils/get-configuration.ts

@@ -71,6 +71,7 @@ export enum CommandName {
     'install' = 'install',
     'kendo-ui-license' = 'kendo-ui-license',
     'lint' = 'lint',
+    'mfe-list' = 'mfe-list',
     'mfe-package-clean' = 'mfe-package-clean',
     'mfe-package-publish' = 'mfe-package-publish',
     'mfe-publish' = 'mfe-publish',

package/src/utils/get-packages.ts

@@ -9,12 +9,9 @@ export enum PackageType {
     Legacy,
 }
 
-export interface Package {
-    name: string;
-    type: PackageType;
-    version: string;
+export interface Package extends ProjectPackage {
     private: boolean;
-    location: string;
+    type: PackageType;
 }
 
 interface GetPackagesOptions {
@@ -113,12 +110,9 @@ function filterPackages(packages: ProjectPackage[], options: GetPackagesOptions)
 
 function withMetadata(packages: ProjectPackage[]): Package[] {
     return packages.map(pkg => {
-        const { name, version, location } = pkg;
         return {
-            name,
-            version,
+            ...pkg,
             private: pkg.private ?? false,
-            location,
             type: getPackageType(pkg),
         };
     });

package/src/utils/get-startup-version.ts

@@ -2,7 +2,5 @@ import path from 'path';
 import { readJson } from './read-json';
 
 export function getStartupVersion() {
-    return readJson(
-        path.join(path.dirname(require.resolve('@servicetitan/startup')), '../package.json')
-    ).version;
+    return readJson(path.join(__dirname, '../../package.json')).version;
 }

package/src/utils/index.ts

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

package/src/webpack/__mocks__/style-rules.ts

@@ -81,7 +81,7 @@ export const styleRules: Record<string, StyleRule> = {
     },
 };
 
-export const webComponentStyleRules = Object.entries(styleRules).reduce(
+export const miniCssPluginStyleRules = Object.entries(styleRules).reduce(
     (result, [key, rule]) => {
         result[key] = { ...rule, use: rule.use?.map(transformStyleLoader) };
         return result;
@@ -89,7 +89,7 @@ export const webComponentStyleRules = Object.entries(styleRules).reduce(
     {} as typeof styleRules
 );
 
-export const productionStyleRules = Object.entries(webComponentStyleRules).reduce(
+export const productionStyleRules = Object.entries(miniCssPluginStyleRules).reduce(
     (result, [key, rule]) => {
         if (key === '.css') {
             result[key] = { ...rule, exclude: /\.module.css$/ }; // production doesn't use callback?!
@@ -98,7 +98,7 @@ export const productionStyleRules = Object.entries(webComponentStyleRules).reduc
         }
         return result;
     },
-    {} as typeof webComponentStyleRules
+    {} as typeof miniCssPluginStyleRules
 );
 
 /**

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -20,7 +20,7 @@ import {
     log,
     pick,
 } from '../../utils';
-import { styleRules } from '../__mocks__';
+import { miniCssPluginStyleRules } from '../__mocks__';
 import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
 import { getModuleEntryPath } from '../utils';
 
@@ -218,7 +218,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     );
                 });
 
-                Object.entries(styleRules).forEach(([extension, rule]) => {
+                Object.entries(miniCssPluginStyleRules).forEach(([extension, rule]) => {
                     test(`configures "${extension}" rules`, () => {
                         expect(subject().module?.rules).toContainEqual(rule);
                     });
@@ -226,12 +226,8 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
 
-        describe('when in production', () => {
-            beforeEach(() => (overrides.configuration = { mode: 'production' }));
-
-            test('configures "output.clean" to keep shared dependencies', () => {
-                expect(subject().output?.clean).toEqual({ keep: /shared/ });
-            });
+        test('configures "output.clean" to keep shared dependencies', () => {
+            expect(subject().output?.clean).toEqual({ keep: /shared/ });
         });
 
         describe('with bundled exposed dependencies', () => {
@@ -408,12 +404,8 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(HtmlWebpackPlugin).not.toHaveBeenCalled();
             });
 
-            describe('when in production', () => {
-                beforeEach(() => (overrides.configuration = { mode: 'production' }));
-
-                test('configures "output.clean" to true', () => {
-                    expect(subject().output?.clean).toBe(true);
-                });
+            test('configures "output.clean" to true', () => {
+                expect(subject().output?.clean).toBe(true);
             });
         });
     });

package/src/webpack/__tests__/create-webpack-config-web-component.test.ts

@@ -15,7 +15,7 @@ import {
     isLegacyRoot,
     isWebComponent,
 } from '../../utils';
-import { webComponentStyleRules } from '../__mocks__';
+import { miniCssPluginStyleRules } from '../__mocks__';
 import { generateMetadata } from '../configs/utils';
 import { getCallerFile, splitByEntry } from '../utils';
 
@@ -119,6 +119,20 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     const subject = () => createWebpackConfig(overrides, options);
 
     describe('when package is a web component', () => {
+        const baseCacheGroups = {
+            styles: {
+                name: 'main',
+                type: 'css/mini-extract',
+                chunks: 'all',
+                enforce: true,
+            },
+            servicetitan: {
+                name: 'servicetitan',
+                test: /[\\/]node_modules[\\/]@servicetitan[\\/]/,
+                chunks: 'all',
+            },
+        };
+
         beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(true));
 
         test('configures MiniCssExtractPlugIn plugin', () => {
@@ -127,7 +141,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             );
         });
 
-        Object.entries(webComponentStyleRules).forEach(([extension, rule]) => {
+        Object.entries(miniCssPluginStyleRules).forEach(([extension, rule]) => {
             test(`configures "${extension}" rules`, () => {
                 expect(subject().module?.rules).toContainEqual(rule);
             });
@@ -139,13 +153,9 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             );
         });
 
-        test('configures "optimization.splitChunks.cacheGroups.styles', () => {
-            expect((subject().optimization?.splitChunks as any).cacheGroups.styles).toEqual({
-                name: 'main',
-                type: 'css/mini-extract',
-                chunks: 'all',
-                enforce: true,
-            });
+        test('configures "optimization.splitChunks.cacheGroups', () => {
+            // @ts-expect-error because splitChunks is polymorphic
+            expect(subject().optimization?.splitChunks.cacheGroups).toEqual(baseCacheGroups);
         });
 
         test('configures WEB_COMPONENT_NAME', () => {
@@ -183,6 +193,25 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
 
+        test('WebpackAssetsManifest plugin moves design system css to precede other css', () => {
+            const assets = {
+                entrypoints: {
+                    foo: {
+                        assets: {
+                            css: ['main.css', 'servicetitan.css', 'common.css'],
+                        },
+                    },
+                },
+            };
+
+            subject();
+
+            const transform: any = jest.mocked(WebpackAssetsManifest).mock.calls[0][0]?.transform;
+            expect(transform(assets)).toEqual(
+                expect.objectContaining({ css: ['servicetitan.css', 'main.css', 'common.css'] })
+            );
+        });
+
         test('generates metadata when WebpackAssetsManifest plugin is done', () => {
             subject();
 
@@ -373,27 +402,21 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(subject().devtool).toBe('source-map');
             });
 
-            test('configures "optimization.splitChunks.cacheGroups"', () => {
+            test('adds "common" and "kendo" to "optimization.splitChunks.cacheGroups"', () => {
                 // @ts-expect-error because splitChunks is polymorphic
-                expect(subject().optimization?.splitChunks.cacheGroups).toEqual(
-                    expect.objectContaining({
-                        common: {
-                            name: 'common',
-                            test: /[\\/]node_modules[\\/](axios|classnames|formstate|mobx|mobx-react|mobx-utils|react|react-dom|react-router|react-router-dom)[\\/]/,
-                            chunks: 'all',
-                        },
-                        kendo: {
-                            name: 'kendo',
-                            test: /[\\/]node_modules[\\/](@progress|@telerik)[\\/]/,
-                            chunks: 'all',
-                        },
-                        servicetitan: {
-                            name: 'servicetitan',
-                            test: /[\\/]node_modules[\\/]@servicetitan[\\/]/,
-                            chunks: 'all',
-                        },
-                    })
-                );
+                expect(subject().optimization?.splitChunks.cacheGroups).toEqual({
+                    ...baseCacheGroups,
+                    common: {
+                        name: 'common',
+                        test: /[\\/]node_modules[\\/](axios|classnames|formstate|mobx|mobx-react|mobx-utils|react|react-dom|react-router|react-router-dom)[\\/]/,
+                        chunks: 'all',
+                    },
+                    kendo: {
+                        name: 'kendo',
+                        test: /[\\/]node_modules[\\/](@progress|@telerik)[\\/]/,
+                        chunks: 'all',
+                    },
+                });
             });
 
             test('configures "output.uniqueName"', () => {

package/src/webpack/configs/loaders/style-loader.ts

@@ -3,9 +3,12 @@ import { Context } from '../types';
 import { LoaderOptions } from './types';
 
 export function styleLoader(
-    { isProduction, isWebComponent }: Context,
+    { isProduction, isWebComponent, emitExposedDependencies }: Context,
     { esModule }: LoaderOptions = {}
 ) {
-    const loader = isProduction || isWebComponent ? MiniCssExtractPlugin.loader : 'style-loader';
+    const loader =
+        isProduction || isWebComponent || emitExposedDependencies
+            ? MiniCssExtractPlugin.loader
+            : 'style-loader';
     return esModule ? { loader, options: { esModule } } : loader;
 }