@servicetitan/startup 30.3.0 → 31.0.0

package/src/cli/commands/review/utils/__tests__/compare-version.test.ts

@@ -0,0 +1,73 @@
+import { compareVersion } from '../compare-version';
+
+describe(`[startup] Review ${compareVersion.name}`, () => {
+    const subject = (a: string, b: string) => compareVersion(a, b);
+
+    const orderedVersions = [
+        '0.9',
+        '<1.0.0',
+        '0.x',
+        '^0',
+        '<=1',
+        '1.0.0',
+        '1.0.x',
+        '~1.0.0',
+        '1.1.0',
+        '~1.1.0',
+        '~1.1.1',
+        '<1.9.0',
+        '<2.0.0',
+        '1.x',
+        '^1.0.0',
+        '^1.1.0',
+        '^1.1.1',
+        '<2.0.1',
+        '2.0.1',
+        '~2.0.0',
+        '2.x',
+        '>=1',
+        '>=1.0.0',
+        '>1.0.0',
+        '>1',
+    ];
+
+    describe('equals', () => {
+        orderedVersions.forEach(version => {
+            test(`"${version}" equals self`, () => {
+                expect(subject(version, version)).toBe(0);
+            });
+        });
+    });
+
+    describe('greater than', () => {
+        orderedVersions.forEach((version, index) => {
+            orderedVersions.slice(index + 1).forEach(greaterVersion => {
+                test(`"${greaterVersion}" is greater than "${version}"`, () => {
+                    expect(subject(greaterVersion, version)).toBe(1);
+                });
+            });
+        });
+    });
+
+    describe('less than', () => {
+        orderedVersions.forEach((version, index) => {
+            orderedVersions.slice(0, index).forEach(lesserVersion => {
+                test(`"${lesserVersion}" is less than "${version}"`, () => {
+                    expect(subject(lesserVersion, version)).toBe(-1);
+                });
+            });
+        });
+    });
+
+    describe('invalid version uses string comparison', () => {
+        const orderedInvalidVersions = ['1.0.a', 'a.2.0', 'a.b.c', 'd.e.f'];
+
+        orderedInvalidVersions.forEach((version, index) => {
+            orderedInvalidVersions.slice(index + 1).forEach(greaterVersion => {
+                test(`"${greaterVersion}" is greater than "${version}"`, () => {
+                    expect(subject(greaterVersion, version)).toBe(1);
+                });
+            });
+        });
+    });
+});

package/src/cli/commands/review/utils/__tests__/get-max-version.test.ts

@@ -0,0 +1,17 @@
+import { getMaxVersion } from '../get-max-version';
+
+describe(`[startup] Review ${getMaxVersion.name}`, () => {
+    const orderedVersions = ['^0', '~1.0.0', '^1', '<=2', '>1'];
+
+    const subject = (versions: string[]) => getMaxVersion(versions);
+
+    orderedVersions.forEach((version, index) => {
+        if (index > 0) {
+            const versions = orderedVersions.slice(0, index + 1);
+            test(`max version of ${JSON.stringify(versions)} is "${version}"`, () => {
+                expect(subject(versions)).toBe(version);
+                expect(subject(versions.toReversed())).toBe(version);
+            });
+        }
+    });
+});

package/src/cli/commands/review/utils/__tests__/indent.test.ts

@@ -0,0 +1,41 @@
+import { indent } from '../indent';
+
+describe(`[startup] Review ${indent.name}`, () => {
+    let text: string | string[];
+    let level: number | undefined;
+
+    beforeEach(() => {
+        text = 'foo';
+        level = undefined;
+    });
+
+    const subject = () => indent(text, level);
+
+    test('prefixes text with two spaces', () => {
+        expect(subject()).toBe(`  ${text}`);
+    });
+
+    describe('with level = 0', () => {
+        beforeEach(() => (level = 0));
+
+        test('omits prefix', () => {
+            expect(subject()).toBe(text);
+        });
+    });
+
+    describe('with level > 0', () => {
+        beforeEach(() => (level = 3));
+
+        test('prefixes text with 2 * level spaces', () => {
+            expect(subject()).toBe(`${'  '.repeat(level!)}${text}`);
+        });
+    });
+
+    describe('when text is array', () => {
+        beforeEach(() => (text = ['foo', 'bar']));
+
+        test('prefixes each element and returns newline-separated string', () => {
+            expect(subject()).toEqual((text as string[]).map(line => `  ${line}`).join('\n'));
+        });
+    });
+});

package/src/cli/commands/review/utils/__tests__/name-to-location.test.ts

@@ -0,0 +1,39 @@
+import path from 'path';
+import { Package } from '../../types';
+import { nameToLocation } from '../name-to-location';
+
+describe(`[startup] Review ${nameToLocation.name}`, () => {
+    let name = 'foo';
+    let pkg: Package;
+    let packages: Package[];
+
+    beforeEach(() => {
+        name = 'foo';
+        pkg = { name, location: `packages/${name}` };
+        packages = [pkg];
+    });
+
+    const subject = () => nameToLocation(name, packages);
+
+    test('returns path to package.json', () => {
+        expect(subject()).toBe(path.normalize(`${pkg.location}/package.json`));
+    });
+
+    function itReturnsName() {
+        test('returns name', () => {
+            expect(subject()).toBe(name);
+        });
+    }
+
+    describe('when package is not found', () => {
+        beforeEach(() => (packages = []));
+
+        itReturnsName();
+    });
+
+    describe('when package has no location', () => {
+        beforeEach(() => (pkg.location = ''));
+
+        itReturnsName();
+    });
+});

package/src/cli/commands/review/utils/__tests__/set-version.test.ts

@@ -0,0 +1,84 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { Package } from '../../types';
+
+import { setVersion } from '../set-version';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+describe(`[startup] Review ${setVersion.name}`, () => {
+    let pkg: Package;
+    let packageName: string;
+    let dependency: string;
+    let version: string;
+
+    beforeEach(() => {
+        packageName = 'lib1';
+        dependency = 'foo';
+        version = '2.0.0';
+        pkg = {
+            name: packageName,
+            location: path.normalize(`packages/${packageName}`),
+            dependencies: { [dependency]: '1.0.0' },
+        };
+        jest.clearAllMocks();
+    });
+
+    const subject = () =>
+        setVersion({ project: { packages: [pkg] } as any, packageName, dependency, version });
+
+    function itDoesNothing() {
+        test('does nothing', () => {
+            subject();
+
+            expect(execSync).not.toHaveBeenCalled();
+        });
+    }
+
+    test('sets dependency version', () => {
+        subject();
+
+        expect(execSync).toHaveBeenCalledWith(
+            `npm pkg set dependencies["${dependency}"]="${version}" -w ${pkg.location}`
+        );
+    });
+
+    describe('when location is root package', () => {
+        beforeEach(() => (pkg.location = '.'));
+
+        test('omits workspace option', () => {
+            subject();
+
+            expect(execSync).toHaveBeenCalledWith(
+                `npm pkg set dependencies["${dependency}"]="${version}"`
+            );
+        });
+    });
+
+    describe('with dev dependency', () => {
+        beforeEach(() => {
+            pkg.devDependencies = pkg.dependencies;
+            delete pkg.dependencies;
+        });
+
+        test('sets dev dependency version', () => {
+            subject();
+
+            expect(execSync).toHaveBeenCalledWith(
+                `npm pkg set devDependencies["${dependency}"]="${version}" -w ${pkg.location}`
+            );
+        });
+    });
+
+    describe('when dependency is missing', () => {
+        beforeEach(() => delete pkg.dependencies);
+
+        itDoesNothing();
+    });
+
+    describe('when package is missing', () => {
+        beforeEach(() => (pkg.name = `!${pkg.name}`));
+
+        itDoesNothing();
+    });
+});

package/src/cli/commands/review/utils/apply-filter.ts

@@ -0,0 +1,14 @@
+import { RuleConfiguration } from '../types';
+
+export function applyFilter<T>(
+    config: RuleConfiguration | undefined,
+    items: T[],
+    getName: (item: T) => string
+) {
+    const { exclude } = (Array.isArray(config) && config[1]) || {}; // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
+    if (Array.isArray(exclude) && exclude.length > 0) {
+        const set = new Set(exclude);
+        return items.filter(item => !set.has(getName(item)));
+    }
+    return items;
+}

package/src/cli/commands/review/utils/collate-dependencies.ts

@@ -0,0 +1,46 @@
+import { validRange } from 'semver';
+import { Dependencies, Package } from '../types';
+
+/**
+ * Collates all dependencies and devDependencies from an array of packages into a Dependencies map.
+ *
+ * For each package, this function collects both `dependencies` and `devDependencies`.
+ * It groups package names by dependency and version, resulting in a structure that shows
+ * which packages depend on which versions of each dependency.
+ *
+ * @param {Package[]} packages The array of Package objects to process.
+ * @returns {Dependencies} An object mapping dependency names to version maps,
+ *   where each version maps to an array of package names that depend on that version.
+ *
+ * @example
+ * // Given:
+ *   packages = [
+ *     { name: 'foo', dependencies: { lodash: '^4.17.21' } },
+ *     { name: 'bar', devDependencies: { lodash: '^4.17.21' } },
+ *     { name: 'baz', dependencies: { lodash: '^4.17.20' } }
+ *   ]
+ * // collateDependencies(packages) returns:
+ *   {
+ *     lodash: {
+ *       '^4.17.21': ['foo', 'bar'],
+ *       '^4.17.20': ['baz']
+ *     }
+ *   }
+ */
+export function collateDependencies(packages: Package[]): Dependencies {
+    return packages.reduce<Dependencies>(
+        (result, { name, dependencies = {}, devDependencies = {} }) => {
+            [...Object.entries(dependencies), ...Object.entries(devDependencies)].forEach(
+                ([dependency, version]) => {
+                    if (validRange(version)) {
+                        result[dependency] ??= {};
+                        result[dependency][version] ??= [];
+                        result[dependency][version].push(name);
+                    }
+                }
+            );
+            return result;
+        },
+        {}
+    );
+}

package/src/cli/commands/review/utils/compare-version.ts

@@ -0,0 +1,82 @@
+import * as semver from 'semver';
+
+const REGEX_PREFIX = /^(\D{1,2})/;
+const REGEX_N_DOT_X = /^\D*\d\.x/; // E.g., 1.x
+const REGEX_N_DOT_N_DOT_X = /^\D*\d\.\d\.x/; // E.g., 1.0.x
+
+const prefixOrder = Object.fromEntries(
+    ['<', '<=', '=', '', '~', '^', '>=', '>'].map((prefix, index) => [prefix, index])
+);
+
+/**
+ * Compare two semver strings.
+ * @returns
+ * - `0` if a == b
+ * - `>0` if a is semantically greater than b (e.g., "^1.0.0" is greater than "~1.0.0")
+ * - `<0` if a is semantically less than b (e.g., "<1" is less than "<=1")
+ */
+export function compareVersion(a: string, b: string) {
+    const max = { a: maxVersion(a), b: maxVersion(b) };
+    if (!(max.a && max.b)) {
+        return a.localeCompare(b);
+    }
+
+    const min = { a: semver.minVersion(a), b: semver.minVersion(b) };
+    const result =
+        semver.compare(max.a, max.b) || // e.g., ^1.0.0 gt ~1.0.0
+        comparePrefix(a, b) || // e.g., ^1 gt 1.x
+        (min.a && min.b ? semver.compare(min.a, min.b) : 0) || // e.g., ^1.1.1 gt ^1.0.0
+        a.length - b.length; //  >=1.0.0 gt >=1
+    return result > 0 ? 1 : result < 0 ? -1 : 0;
+}
+
+function comparePrefix(a: string, b: string) {
+    return prefixOrder[getPrefix(a)] - prefixOrder[getPrefix(b)];
+}
+
+function getPrefix(version: string, { infer = false }: { infer?: boolean } = {}) {
+    if (infer) {
+        if (REGEX_N_DOT_X.test(version)) {
+            return '^';
+        }
+        if (REGEX_N_DOT_N_DOT_X.test(version)) {
+            return '~';
+        }
+    }
+    return REGEX_PREFIX.exec(version)?.[1].trim() ?? '';
+}
+
+function maxVersion(str: string) {
+    if (!semver.validRange(str)) {
+        return;
+    }
+
+    const v = semver.coerce(str);
+    if (!v) {
+        return;
+    }
+
+    const prefix = getPrefix(str, { infer: true });
+    if (prefix === '<') {
+        if (v.patch) {
+            return new semver.SemVer(`${v.major}.${v.minor}.${v.patch - 1}`);
+        }
+        if (v.minor) {
+            return new semver.SemVer(`${v.major}.${v.minor - 1}.999`);
+        }
+        if (v.major) {
+            return new semver.SemVer(`${v.major - 1}.999.999`);
+        }
+    }
+    if (prefix === '~') {
+        return new semver.SemVer(`${v.major}.${v.minor}.999`);
+    }
+    if (prefix === '^') {
+        return new semver.SemVer(`${v.major}.999.999`);
+    }
+    if (prefix === '>=' || prefix === '>') {
+        return new semver.SemVer('999.999.999');
+    }
+
+    return v;
+}

package/src/cli/commands/review/utils/format-depends-on.ts

@@ -0,0 +1,11 @@
+const collator = new Intl.Collator();
+
+export function formatDependsOn(dependents: string[], dependency: string) {
+    const { length } = dependents;
+    if (length === 1) {
+        return `${dependents[0]} depends on ${dependency}`;
+    }
+
+    const sorted = dependents.toSorted((a, b) => collator.compare(a, b));
+    return `${sorted.slice(0, -1).join(', ')} and ${sorted[length - 1]} depend on ${dependency}`;
+}

package/src/cli/commands/review/utils/format-location.ts

@@ -0,0 +1,8 @@
+import fs from 'fs';
+import path from 'path';
+
+export function formatLocation(location: string) {
+    return fs.lstatSync(location, { throwIfNoEntry: false })?.isFile()
+        ? path.relative('.', location)
+        : path.relative('.', path.join(location, 'package.json'));
+}

package/src/cli/commands/review/utils/get-key.ts

@@ -0,0 +1,10 @@
+import { Package } from '../types';
+
+export function getKey({ dependencies, devDependencies }: Package, dependency: string) {
+    if (dependencies?.[dependency]) {
+        return 'dependencies';
+    }
+    if (devDependencies?.[dependency]) {
+        return 'devDependencies';
+    }
+}

package/src/cli/commands/review/utils/get-max-version.ts

@@ -0,0 +1,5 @@
+import { compareVersion } from './compare-version';
+
+export function getMaxVersion(versions: string[]) {
+    return versions.reduce((max, version) => (compareVersion(version, max) > 0 ? version : max));
+}

package/src/cli/commands/review/utils/indent.ts

@@ -0,0 +1,8 @@
+import { toArray } from '../../../../utils';
+
+export function indent(output: string | string[], level: number = 1) {
+    const prefix = '  '.repeat(level);
+    return toArray(output)
+        .map(line => `${prefix}${line}`)
+        .join('\n');
+}

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

@@ -0,0 +1,13 @@
+export * from './apply-filter';
+export * from './collate-dependencies';
+export * from './compare-version';
+export * from './format-depends-on';
+export * from './format-location';
+export * from './get-key';
+export * from './get-max-version';
+export * from './indent';
+export * from './is-library';
+export * from './name-to-location';
+export * from './pluralize';
+export * from './set-version';
+export * from './summarize';

package/src/cli/commands/review/utils/is-library.ts

@@ -0,0 +1,5 @@
+import { Package } from '../types';
+
+export function isLibrary({ cli }: Package) {
+    return cli?.webpack === false;
+}

package/src/cli/commands/review/utils/name-to-location.ts

@@ -0,0 +1,7 @@
+import { Package } from '../types';
+import { formatLocation } from './format-location';
+
+export function nameToLocation(name: string, packages: Package[]) {
+    const location = packages.find(pkg => pkg.name === name)?.location;
+    return location ? formatLocation(location) : name;
+}

package/src/cli/commands/review/utils/pluralize.ts

@@ -0,0 +1,3 @@
+export function pluralize(value: number, singular: string, plural?: string) {
+    return value + ' ' + (value === 1 ? singular : (plural ?? `${singular}s`));
+}

package/src/cli/commands/review/utils/set-version.ts

@@ -0,0 +1,26 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { Project } from '../types';
+import { getKey } from './get-key';
+
+interface Params {
+    project: Project;
+    packageName: string;
+    dependency: string;
+    version: string;
+}
+export function setVersion({ project: { packages }, packageName, dependency, version }: Params) {
+    const pkg = packages.find(({ name }) => name === packageName);
+    if (!pkg) {
+        return;
+    }
+
+    const key = getKey(pkg, dependency);
+    if (!key) {
+        return;
+    }
+
+    const workspace = path.relative('.', pkg.location);
+    const command = `npm pkg set ${key}["${dependency}"]="${version}"${workspace ? ` -w ${workspace}` : ''}`;
+    execSync(command);
+}

package/src/cli/commands/review/utils/summarize.ts

@@ -0,0 +1,21 @@
+import { ErrorSeverity, PackageError } from '../types';
+
+export interface ErrorSummary {
+    error: number;
+    warning: number;
+    fixable: { error: number; warning: number };
+}
+
+export function summarize(errors: PackageError[]): ErrorSummary {
+    return errors.reduce(
+        (result, { fixable, severity = ErrorSeverity.error }) => {
+            const type = severity === ErrorSeverity.error ? 'error' : 'warning';
+            result[type] += 1;
+            if (fixable) {
+                result.fixable[type] += 1;
+            }
+            return result;
+        },
+        { error: 0, warning: 0, fixable: { error: 0, warning: 0 } }
+    );
+}

package/src/cli/commands/run-task.test.ts

@@ -0,0 +1,60 @@
+import { SwcCompilePackage } from '../tasks/swc-compile-package';
+import { TscCompile } from '../tasks/tsc-compile';
+import { TscCompilePackage } from '../tasks/tsc-compile-package';
+
+import { RunTask } from './run-task';
+import { log } from '../../utils';
+
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    log: { error: jest.fn(), text: jest.fn() },
+}));
+jest.mock('../tasks/swc-compile-package');
+jest.mock('../tasks/tsc-compile');
+jest.mock('../tasks/tsc-compile-package');
+
+describe(`[startup] ${RunTask.name}`, () => {
+    let args: ConstructorParameters<typeof RunTask>[0];
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    const subject = () => new RunTask(args).execute();
+
+    const supportedTasks = {
+        'tsc-compile-package': TscCompilePackage,
+        'swc-compile-package': SwcCompilePackage,
+        'tsc-compile': TscCompile,
+    };
+
+    Object.entries(supportedTasks).forEach(([name, task]) =>
+        describe(`with ${name}`, () => {
+            beforeEach(() => (args = { _: [name] })); // eslint-disable-line @typescript-eslint/naming-convention
+
+            test(`runs ${task.name}`, async () => {
+                await subject();
+
+                expect(jest.mocked(task).mock.instances[0].execute).toHaveBeenCalled();
+            });
+        })
+    );
+
+    describe('with unrecognized task', () => {
+        beforeEach(() => (args = { _: ['foo'] })); // eslint-disable-line @typescript-eslint/naming-convention
+
+        test('logs error', async () => {
+            await subject();
+
+            expect(log.error).toHaveBeenCalledWith(`Unknown task: "${args._[0]}"`);
+        });
+
+        test('lists supported tasks', async () => {
+            await subject();
+
+            expect(log.text).toHaveBeenCalledWith(
+                `\nSupported tasks: "${Object.keys(supportedTasks).join('", "')}"`
+            );
+        });
+    });
+});