@servicetitan/startup 32.1.0 → 32.3.0

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,24 +1,26 @@
 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')) {
-        fs.mkdirSync('.git');
+        /*
+         * Using {recursive: true} to ignore if directory exists. This happens
+         * when parallel process creates the directory after we've checked
+         * whether it exists.
+         */
+        fs.mkdirSync('.git', { recursive: true });
     }
 }

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-jest-config.test.ts

@@ -2,6 +2,7 @@ import { Config } from '@jest/types';
 import path from 'path';
 import { getJestConfiguration } from '../get-configuration';
 import { getDestinationFolders } from '../get-destination-folders';
+import { pick } from '../pick';
 
 import { getJestConfigCLI } from '../get-jest-config';
 
@@ -76,5 +77,48 @@ describe('[startup] Utils', () => {
                 expect.objectContaining({ transform: JSON.stringify(transform) })
             );
         });
+
+        describe('with "omitDefault"', () => {
+            beforeEach(() => {
+                jest.mocked(getJestConfiguration).mockReturnValue({
+                    omitDefault: Object.keys(defaultConfig),
+                });
+            });
+
+            test('omits specified defaults', () => {
+                expect(pick(subject(), getJestConfiguration().omitDefault!)).toEqual({});
+            });
+        });
+
+        describe.each(['coveragePathIgnorePatterns', 'setupFiles', 'testPathIgnorePatterns'])(
+            'with custom "%s"',
+            key => {
+                let customConfig: Record<string, string[]>;
+
+                beforeEach(() => {
+                    customConfig = { [key]: ['foo'] };
+                    jest.mocked(getJestConfiguration).mockReturnValue(customConfig);
+                });
+
+                test('appends custom value to default', () => {
+                    expect(subject()).toEqual(
+                        expect.objectContaining({
+                            [key]: [
+                                ...defaultConfig[key],
+                                ...(getJestConfiguration()[key] as string[]),
+                            ],
+                        })
+                    );
+                });
+
+                describe('when default is omitted', () => {
+                    beforeEach(() => (customConfig.omitDefault = [key]));
+
+                    test('returns only custom value', () => {
+                        expect(subject()[key]).toEqual(customConfig[key]);
+                    });
+                });
+            }
+        );
     });
 });

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

@@ -51,7 +51,9 @@ export interface StylelintConfiguration extends Partial<LinterOptions> {
     disabled?: boolean;
 }
 
-export type JestConfiguration = Omit<Config.Argv, '_' | '$0'>;
+export interface JestConfiguration extends Omit<Config.Argv, '_' | '$0'> {
+    omitDefault?: string[];
+}
 
 export interface NodeConfiguration {
     // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -69,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',
@@ -82,7 +85,9 @@ export enum CommandName {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
-export type VitestConfiguration = ViteUserConfig['test'];
+export type VitestConfiguration = ViteUserConfig['test'] & {
+    omitDefault?: string[];
+};
 
 export interface WebComponentBranchConfigs {
     publishTag?: string;

package/src/utils/get-jest-config.ts

@@ -3,16 +3,9 @@ import path from 'path';
 import { getJestConfiguration } from './get-configuration';
 import { getDestinationFolders } from './get-destination-folders';
 import { toArray } from './to-array';
+import { omit } from './omit';
 
-function getDefaultJestConfiguration({
-    coveragePathIgnorePatterns = [],
-    setupFiles = [],
-    testPathIgnorePatterns = [],
-}: {
-    coveragePathIgnorePatterns?: string[];
-    setupFiles?: string[];
-    testPathIgnorePatterns?: string[];
-}) {
+function getDefaultJestConfiguration() {
     const moduleNameMapper = {
         '\\.(css|scss|less|png|svg|svg\\?\\w+|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$':
             'identity-obj-proxy',
@@ -20,21 +13,21 @@ function getDefaultJestConfiguration({
 
     return {
         collectCoverageFrom: ['**/*.{ts,tsx}'],
-        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
+        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         moduleNameMapper,
         modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
         preset: path.join(__dirname, '../../jest'),
-        setupFiles: [path.join(__dirname, '../../jest/setup.js'), ...toArray(setupFiles)],
+        setupFiles: [path.join(__dirname, '../../jest/setup.js')],
         testEnvironment: 'jsdom',
-        testPathIgnorePatterns: [
-            '\\.yalc',
-            ...getDestinationFolders(),
-            ...toArray(testPathIgnorePatterns),
-        ],
+        testPathIgnorePatterns: ['\\.yalc', ...getDestinationFolders()],
         testRunner: 'jest-circus/runner',
         transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
         verbose: true,
+    } as Omit<Config.Argv, 'collectCoverageFrom' | 'moduleNameMapper' | 'setupFiles'> & {
+        collectCoverageFrom: string[];
+        moduleNameMapper: Record<string, string>;
+        setupFiles: string[];
     };
 }
 
@@ -42,13 +35,21 @@ function getDefaultJestConfiguration({
  * Get Jest config for running it using jest CLI (see jest runCLI function)
  */
 export function getJestConfigCLI(args: Config.Argv): Config.Argv {
-    const { coveragePathIgnorePatterns, setupFiles, testPathIgnorePatterns, ...config } = {
+    const {
+        coveragePathIgnorePatterns,
+        omitDefault = [],
+        setupFiles,
+        testPathIgnorePatterns,
+        ...config
+    } = {
         ...getJestConfiguration(),
         ...args,
     };
 
+    const defaultConfig = omit(getDefaultJestConfiguration(), omitDefault);
+
     return stringifyForCLI({
-        ...getDefaultJestConfiguration({
+        ...mergeArrayValues(defaultConfig, {
             coveragePathIgnorePatterns,
             setupFiles,
             testPathIgnorePatterns,
@@ -57,6 +58,23 @@ export function getJestConfigCLI(args: Config.Argv): Config.Argv {
     });
 }
 
+function mergeArrayValues(
+    config: any,
+    arrayValues: {
+        coveragePathIgnorePatterns?: string | string[];
+        setupFiles?: string | string[];
+        testPathIgnorePatterns?: string | string[];
+    }
+) {
+    return Object.keys(arrayValues).reduce((result, key: keyof typeof arrayValues) => {
+        const newValue = arrayValues[key];
+        if (newValue) {
+            result[key] = [...toArray(result[key]), ...toArray(newValue)];
+        }
+        return result;
+    }, config);
+}
+
 function stringifyForCLI(config: any): Config.Argv {
     return ['collectCoverageFrom', 'globals', 'moduleNameMapper', 'transform'].reduce(
         (result, key) => {

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';
@@ -14,6 +15,7 @@ export * from './get-tsconfig';
 export * from './load-shared-dependencies';
 export * from './log';
 export * from './log-errors';
+export * from './omit';
 export * from './pick';
 export * from './read-json';
 export * from './to-array';

package/src/utils/omit.ts

@@ -0,0 +1,12 @@
+export function omit<T extends Record<string, any>>(obj: T, keys: string[]): T {
+    return keys.reduce((result, key) => omitInternal({ ...result }, key.split('.')), obj);
+}
+
+function omitInternal<T extends Record<string, any>>(obj: T, [key, ...rest]: string[]): T {
+    if (!rest.length) {
+        delete obj[key];
+    } else if (typeof obj[key] === 'object') {
+        return { ...obj, [key]: omitInternal(obj[key], rest) };
+    }
+    return obj;
+}

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