@servicetitan/startup 32.2.0 → 32.3.1

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

@@ -1,57 +1,36 @@
 import { fs, vol } from 'memfs';
 
 import { maybeCreateGitFolder } from '../maybe-create-git-folder';
-import { Init } from '../../commands/init';
-import { Start } from '../../commands/start';
 
 jest.mock('fs', () => fs);
 
 describe(`[startup] Utils`, () => {
     describe(`${maybeCreateGitFolder.name}`, () => {
-        let command: Parameters<typeof maybeCreateGitFolder>[0];
         const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
 
         beforeEach(() => {
-            command = Start;
-            vol.fromJSON({});
+            jest.clearAllMocks();
+            vol.fromJSON({ 'lerna.json': '' });
         });
 
         afterEach(() => vol.reset);
 
-        const subject = () => maybeCreateGitFolder(command);
+        const subject = () => maybeCreateGitFolder();
 
-        function itDoesNotCreateGitFolder() {
-            test('does not create .git folder', () => {
-                subject();
+        test('creates .git folder', () => {
+            subject();
 
-                expect(mkdirSpy).not.toHaveBeenCalledWith();
-            });
-        }
+            expect(mkdirSpy).toHaveBeenCalledWith('.git', { recursive: true });
+        });
 
-        describe('when running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'win32' });
-            });
+        describe('when directory does not contain lerna.json', () => {
+            beforeEach(() => fs.rmSync('lerna.json'));
 
-            test('creates .git folder', () => {
+            test('does not create .git folder', () => {
                 subject();
 
-                expect(mkdirSpy).toHaveBeenCalledWith('.git', { recursive: true });
+                expect(mkdirSpy).not.toHaveBeenCalled();
             });
-
-            describe('when command is Init', () => {
-                beforeEach(() => (command = Init));
-
-                itDoesNotCreateGitFolder();
-            });
-        });
-
-        describe('when not running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-            });
-
-            itDoesNotCreateGitFolder();
         });
     });
 });

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/lerna-exec.ts

@@ -3,6 +3,7 @@ import os from 'node:os';
 
 import { log } from '../../utils';
 import { isCI } from './is-ci';
+import { maybeCreateGitFolder } from './maybe-create-git-folder';
 
 interface Args {
     'bail'?: boolean;
@@ -15,6 +16,8 @@ interface Args {
 }
 
 export function lernaExec(args: Args) {
+    maybeCreateGitFolder();
+
     const lernaArguments = [
         'exec',
         ...getOptions(args),

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

@@ -1,24 +1,17 @@
 import fs from 'fs';
-
-import { Init } from '../commands/init';
-import { Command, Newable } from '../commands/types';
+import { log } from '../../utils';
 
 /**
  * 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) {
-        return;
-    }
-    if (!fs.existsSync('.git')) {
+export function maybeCreateGitFolder() {
+    if (!fs.existsSync('.git') && fs.existsSync('lerna.json')) {
+        log.debug('maybe-create-git-folder', 'creating .git folder');
         /*
          * Using {recursive: true} to ignore if directory exists. This happens
          * when parallel process creates the directory after we've checked

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