@servicetitan/startup 30.3.1 → 31.0.0

package/src/cli/commands/review/rules/no-typescript-entry-point.ts

@@ -0,0 +1,78 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import { getFolders, log } from '../../../../utils';
+import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter } from '../utils';
+
+interface ErrorData {
+    key: string;
+    value: string;
+}
+
+export class NoTypescriptEntryPoint implements PackageRule {
+    get id() {
+        return 'no-typescript-entry-point';
+    }
+
+    run({ config, packages }: Project): PackageError<ErrorData>[] {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, packages, ({ name }) => name).flatMap(pkg =>
+            this.checkEntryPoints(pkg)
+        );
+    }
+
+    fix({ data, location }: PackageError<ErrorData>) {
+        const { key, value } = data ?? {};
+        if (!(key && value && location)) {
+            return;
+        }
+
+        const workspace = path.relative('.', location);
+        const { source, destination } = getFolders(location);
+        const newValue = value.replace(source, destination).replace(/\.ts$/, '.js');
+        const command = `npm pkg set "${key}"="${newValue}" -w ${workspace}`;
+        log.debug(`review:${this.id}`, `Running ${command}`);
+        execSync(command);
+    }
+
+    private checkEntryPoints(pkg: Package) {
+        const errors: PackageError<ErrorData>[] = [];
+        const addError = (message: string, data: ErrorData) =>
+            errors.push({
+                id: this.id,
+                message,
+                location: pkg.location,
+                fixable: FixCategory.normal,
+                data,
+            });
+
+        (['main', 'module', 'exports'] as (keyof Package)[]).forEach(key => {
+            const value = pkg[key];
+            if (typeof value === 'string' && this.isTypescriptEntryPoint(value)) {
+                addError(`"${key}" is Typescript: ${value}`, { key, value });
+            }
+        });
+
+        if (pkg.exports && typeof pkg.exports !== 'string') {
+            const checkExports = (exports: NonNullable<Package['exports']>, prefix: string) => {
+                Object.entries(exports).forEach(([key, value]) => {
+                    const path = `${prefix}[${key}]`;
+                    if (typeof value === 'string') {
+                        if (this.isTypescriptEntryPoint(value)) {
+                            addError(`"${path}" is Typescript: ${value}`, { key: path, value });
+                        }
+                    } else if (exports) {
+                        checkExports(value, path);
+                    }
+                });
+            };
+            checkExports(pkg.exports, 'exports');
+        }
+
+        return errors;
+    }
+
+    private isTypescriptEntryPoint(str: string) {
+        return str.endsWith('.ts') && !str.endsWith('.d.ts');
+    }
+}

package/src/cli/commands/review/rules/require-explicit-side-effects.ts

@@ -0,0 +1,31 @@
+import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, isLibrary } from '../utils';
+
+export class RequireExplicitSideEffects implements PackageRule {
+    get id() {
+        return 'require-explicit-side-effects';
+    }
+
+    run({ config, packages }: Project): PackageError[] {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
+            if (this.needsSideEffects(pkg)) {
+                result.push({
+                    id: this.id,
+                    message: `package "${pkg.name}" omits sideEffects property`,
+                    severity: ErrorSeverity.warning,
+                    location: pkg.location,
+                });
+            }
+            return result;
+        }, [] as PackageError[]);
+    }
+
+    private needsSideEffects(pkg: Package) {
+        return (
+            isLibrary(pkg) &&
+            (pkg.main !== undefined || pkg.exports !== undefined) &&
+            pkg.sideEffects === undefined
+        );
+    }
+}

package/src/cli/commands/review/rules/require-npmrc.ts

@@ -0,0 +1,27 @@
+import { execSync } from 'child_process';
+import { log } from '../../../../utils';
+import { ErrorSeverity, FixCategory, PackageError, PackageRule } from '../types';
+
+export class RequireNpmrc implements PackageRule {
+    get id() {
+        return 'require-npmrc';
+    }
+
+    run(): PackageError | undefined {
+        const stdout = execSync('npm config list --json', { encoding: 'utf8' });
+        if (JSON.parse(stdout)['legacy-peer-deps'] !== true) {
+            return {
+                id: this.id,
+                message: 'project does not contain .npmrc with legacy-peer-deps=true',
+                severity: ErrorSeverity.warning,
+                fixable: FixCategory.isolated,
+            };
+        }
+    }
+
+    fix() {
+        const command = 'npm config set --location=project legacy-peer-deps=true';
+        log.debug(`review:${this.id}`, `Running ${command}`);
+        execSync(command);
+    }
+}

package/src/cli/commands/review/rules/require-one-anvil-uikit-contrib-version.ts

@@ -0,0 +1,20 @@
+import { RequireOneCollectionVersion } from './require-one-collection-version';
+
+const ANVIL_UIKIT_PACKAGES = [
+    '@servicetitan/confirm-navigation',
+    '@servicetitan/confirm',
+    '@servicetitan/culture',
+    '@servicetitan/data-query',
+    '@servicetitan/datetime-utils',
+    '@servicetitan/form-state',
+    '@servicetitan/form',
+    '@servicetitan/link-item',
+    '@servicetitan/notifications',
+    '@servicetitan/table',
+];
+
+export class RequireOneAnvilUikitContribVersion extends RequireOneCollectionVersion {
+    constructor() {
+        super({ name: 'anvil-uikit-contrib', packages: ANVIL_UIKIT_PACKAGES });
+    }
+}

package/src/cli/commands/review/rules/require-one-collection-version.ts

@@ -0,0 +1,169 @@
+import chalk from 'chalk';
+import { log } from '../../../../utils';
+import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, compareVersion, formatDependsOn, nameToLocation, setVersion } from '../utils';
+
+export interface Collection {
+    name: string;
+    packages: string[];
+}
+
+/**
+ * Maps version number to packages with that version and their dependents.
+ */
+interface Versions {
+    [version: string]: {
+        [packageName: string]: string[];
+    };
+}
+
+interface ErrorData {
+    targetVersion: string;
+    otherVersions: Versions;
+}
+
+interface ErrorDetail {
+    dependents: string[];
+    extra: boolean;
+    packageName: string;
+}
+
+export class RequireOneCollectionVersion implements PackageRule {
+    constructor(private readonly collection: Collection) {}
+
+    get id() {
+        return `require-one-${this.collection.name}-version`;
+    }
+
+    run(project: Project): PackageError<ErrorData> | undefined {
+        const versions = this.collateVersions(project);
+
+        /* istanbul ignore next: debug only */
+        log.debug(`review:${this.collection.name}-versions`, () =>
+            JSON.stringify(versions, null, 2)
+        );
+
+        const keys = Object.keys(versions);
+        if (keys.length <= 1) {
+            return;
+        }
+
+        const message = `project depends on multiple versions of ${this.collection.name} packages`;
+        const details = this.composeDetails(project, versions);
+        const targetVersion = keys[0];
+        const otherVersions = Object.fromEntries(Object.entries(versions).slice(1));
+        return {
+            id: this.id,
+            message,
+            details,
+            fixable: FixCategory.normal,
+            data: { targetVersion, otherVersions },
+        };
+    }
+
+    fix({ data }: PackageError<ErrorData>, project: Project) {
+        const { targetVersion, otherVersions } = data ?? {};
+        if (!(targetVersion && otherVersions)) {
+            return;
+        }
+
+        Object.values(otherVersions).forEach(packages => {
+            Object.entries(packages).forEach(([name, dependents]) => {
+                dependents.forEach(dependent =>
+                    setVersion({
+                        project,
+                        packageName: dependent,
+                        dependency: name,
+                        version: targetVersion,
+                    })
+                );
+            });
+        });
+    }
+
+    private collateVersions(project: Project) {
+        const dependencies = this.getDependencies(project);
+        return this.sortVersions(
+            this.collection.packages.reduce<Versions>((result, name) => {
+                Object.entries(dependencies[name] ?? {}).forEach(([version, dependents]) => {
+                    result[version] ??= {};
+                    result[version][name] = dependents;
+                });
+                return result;
+            }, {})
+        );
+    }
+
+    private composeDetails({ packages }: Project, versions: Versions) {
+        const extra = this.getExtra(versions);
+        return this.sortDetails(this.getDetails(packages, versions, extra)).map(detail =>
+            this.formatDetail(detail)
+        );
+    }
+
+    private formatDetail({ dependents, packageName, extra }: ErrorDetail) {
+        return formatDependsOn(dependents, chalk[extra ? 'red' : 'yellow'](packageName));
+    }
+
+    private getDependencies({ config, dependencies }: Project) {
+        const ruleConfig = config.rules?.[this.id];
+        return Object.fromEntries(
+            applyFilter(ruleConfig, Object.entries(dependencies), ([name]) => name)
+        ) as Project['dependencies'];
+    }
+
+    private getDetails(packages: Package[], versions: Versions, extra: Set<string>) {
+        return Object.entries(versions).reduce((result, [version, dependencies]) => {
+            Object.entries(dependencies).forEach(([pkg, dependents]) => {
+                result.push({
+                    packageName: `${pkg}@${version}`,
+                    dependents: dependents.map(name => nameToLocation(name, packages)),
+                    extra: extra.has(pkg),
+                });
+            });
+            return result;
+        }, [] as ErrorDetail[]);
+    }
+
+    /**
+     * Assumes first version is the most common and the other ones are extra (see sortVersions)
+     */
+    private getExtra(versions: Versions): Set<string> {
+        return new Set(
+            Object.entries(versions)
+                .slice(1)
+                .flatMap(([_version, dependencies]) =>
+                    Object.entries(dependencies).map(([pkg]) => pkg)
+                )
+        );
+    }
+
+    /**
+     * Orders details so that extraneous packages are at the top
+     */
+    private sortDetails(details: ErrorDetail[]) {
+        return details.sort((a, b) => {
+            if (a.extra === b.extra) {
+                return 0;
+            }
+            return a.extra === true ? -1 : 1;
+        });
+    }
+
+    /**
+     * Orders versions in descending order by the number of packages using the version
+     * and then by version number. I.e., It puts most common version at the top and if
+     * multiple versions tie for the top position, it puts the highest version first.
+     */
+    private sortVersions(versions: Versions): Versions {
+        return Object.fromEntries(
+            Object.entries(versions)
+                .sort(
+                    ([v1, depsV1], [v2, depsV2]) =>
+                        Object.keys(depsV1).length - Object.keys(depsV2).length ||
+                        compareVersion(v1, v2)
+                )
+                .reverse()
+        );
+    }
+}

package/src/cli/commands/review/rules/require-one-package-version.ts

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import { FixCategory, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, formatDependsOn, getMaxVersion, nameToLocation, setVersion } from '../utils';
+
+interface ErrorData {
+    name: string;
+    versions: Versions;
+}
+
+/**
+ * Maps versions to their dependents
+ */
+interface Versions {
+    [key: string]: string[];
+}
+
+export class RequireOnePackageVersion implements PackageRule {
+    get id() {
+        return 'require-one-package-version';
+    }
+
+    run(project: Project) {
+        const errors: PackageError<ErrorData>[] = [];
+
+        this.getDependencies(project).forEach(([name, versions]) => {
+            if (Object.keys(versions).length > 1) {
+                const message = `project depends on multiple versions of "${name}"`;
+                const details = this.formatDetails(project, versions);
+                errors.push({
+                    id: this.id,
+                    message,
+                    details,
+                    fixable: FixCategory.isolated,
+                    data: { name, versions },
+                });
+            }
+        });
+
+        return errors;
+    }
+
+    fix({ data }: PackageError<ErrorData>, project: Project) {
+        const { name, versions } = data ?? {};
+        if (!(name && versions)) {
+            return;
+        }
+
+        const targetVersion = getMaxVersion(Object.keys(versions));
+        Object.entries(versions).forEach(([version, dependents]) => {
+            if (version !== targetVersion) {
+                dependents.forEach(dependent =>
+                    setVersion({
+                        project,
+                        packageName: dependent,
+                        dependency: name,
+                        version: targetVersion,
+                    })
+                );
+            }
+        });
+    }
+
+    private formatDetails({ packages }: Project, versions: Versions) {
+        return Object.entries(versions).map(([version, dependents]) =>
+            formatDependsOn(
+                dependents.map(name => nameToLocation(name, packages)),
+                chalk.yellow(version)
+            )
+        );
+    }
+
+    private getDependencies({ config, dependencies }: Project) {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, Object.entries(dependencies), ([name]) => name);
+    }
+}

package/src/cli/commands/review/rules/require-one-uikit-version.ts

@@ -0,0 +1,27 @@
+import { RequireOneCollectionVersion } from './require-one-collection-version';
+
+const UIKIT_PACKAGES = [
+    '@servicetitan/ajax-handlers',
+    '@servicetitan/error-boundary',
+    '@servicetitan/eslint-config',
+    '@servicetitan/eslint-plugin',
+    '@servicetitan/eslint-plugin-folder-schema',
+    '@servicetitan/folder-lint',
+    '@servicetitan/hash-browser-router',
+    '@servicetitan/ko-bridge',
+    '@servicetitan/launchdarkly-service',
+    '@servicetitan/lazy-module',
+    '@servicetitan/log-service',
+    '@servicetitan/react-ioc',
+    '@servicetitan/restrict-imports',
+    '@servicetitan/startup',
+    '@servicetitan/stylelint-config',
+    '@servicetitan/suppress-warnings',
+    '@servicetitan/web-components',
+];
+
+export class RequireOneUikitVersion extends RequireOneCollectionVersion {
+    constructor() {
+        super({ name: 'uikit', packages: UIKIT_PACKAGES });
+    }
+}

package/src/cli/commands/review/rules/require-project-version-in-root-node-modules.ts

@@ -0,0 +1,104 @@
+import chalk from 'chalk';
+import { satisfies } from 'semver';
+import { FixCategory, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, getKey, getMaxVersion } from '../utils';
+import { execSync } from 'child_process';
+import { log } from '../../../../utils';
+
+interface Mismatch {
+    name: string;
+    projectVersions: string[];
+    rootVersion: string;
+}
+
+interface ErrorData {
+    mismatches: Mismatch[];
+}
+
+export class RequireProjectVersionInRootNodeModules implements PackageRule {
+    get id() {
+        return 'require-project-version-in-root-node-modules';
+    }
+
+    run(project: Project): PackageError<ErrorData> | undefined {
+        const mismatches = this.findMismatches(project);
+        if (!mismatches.length) {
+            return;
+        }
+
+        return {
+            id: this.id,
+            message: 'project has unexpected version in root node_modules',
+            details: this.formatDetails(mismatches),
+            fixable: FixCategory.lockFile,
+            location: project.packageLock.location,
+            data: { mismatches },
+        };
+    }
+
+    fix({ data }: PackageError<ErrorData>, project: Project) {
+        const { mismatches } = data ?? {};
+        if (!mismatches) {
+            return;
+        }
+
+        const root = project.packages.find(({ location }) => location === '.');
+        if (!root) {
+            return;
+        }
+
+        const dependencies = mismatches.reduce<Record<string, string>>(
+            (result, { name, projectVersions }) => {
+                if (!getKey(root, name)) {
+                    result[name] = getMaxVersion(projectVersions);
+                }
+                return result;
+            },
+            {}
+        );
+
+        const entries = Object.entries(dependencies);
+        if (entries.length === 0) {
+            return;
+        }
+
+        /* istanbul ignore next: debug only */
+        log.debug(`review:${this.id}`, () => JSON.stringify(dependencies, null, 2));
+
+        entries.forEach(([name, version]) =>
+            execSync(`npm pkg set dependencies["${name}"]="${version}"`, { stdio: 'inherit' })
+        );
+
+        execSync('npx startup install --fix --quiet', { stdio: 'inherit' });
+
+        entries.forEach(([name]) =>
+            execSync(`npm pkg delete dependencies["${name}"]`, { stdio: 'inherit' })
+        );
+    }
+
+    private formatDetails(mismatches: Mismatch[]) {
+        return mismatches.map(({ name, projectVersions, rootVersion }) => {
+            const pkg = chalk.yellow(`${name}@${rootVersion}`);
+            return `${pkg} does not match ${chalk.yellow(projectVersions.join(', '))}`;
+        });
+    }
+
+    private findMismatches(project: Project) {
+        const { packageLock } = project;
+        return this.getDependencies(project).reduce((result, [name, versions]) => {
+            const rootVersion = packageLock.packages[`node_modules/${name}`]?.version;
+            if (rootVersion) {
+                const projectVersions = Object.keys(versions);
+                if (!projectVersions.some(version => satisfies(rootVersion, version))) {
+                    result.push({ name, projectVersions, rootVersion });
+                }
+            }
+            return result;
+        }, [] as Mismatch[]);
+    }
+
+    private getDependencies({ config, dependencies }: Project) {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, Object.entries(dependencies), ([name]) => name);
+    }
+}

package/src/cli/commands/review/rules/require-servicetitan-scope.ts

@@ -0,0 +1,27 @@
+import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
+import { applyFilter, isLibrary } from '../utils';
+
+export class RequireServiceTitanScope implements PackageRule {
+    get id() {
+        return 'require-servicetitan-scope';
+    }
+
+    run({ config, packages }: Project): PackageError[] {
+        const ruleConfig = config.rules?.[this.id];
+        return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
+            if (this.needsScope(pkg)) {
+                result.push({
+                    id: this.id,
+                    message: `package "${pkg.name}" should have @servicetitan scope`,
+                    severity: ErrorSeverity.warning,
+                    location: pkg.location,
+                });
+            }
+            return result;
+        }, [] as PackageError[]);
+    }
+
+    private needsScope(pkg: Package) {
+        return isLibrary(pkg) && pkg.private !== true && !pkg.name.startsWith('@servicetitan/');
+    }
+}

package/src/cli/commands/review/types.ts

@@ -0,0 +1,72 @@
+export abstract class PackageRule {
+    abstract get id(): string;
+    abstract run(project: Project): PackageError | PackageError[] | undefined;
+    abstract fix?(error: PackageError, project: Project): void;
+}
+
+export interface Project {
+    config: ReviewConfiguration;
+    dependencies: Dependencies;
+    // Only using this subset of package-lock.json
+    packageLock: { packages: Record<string, { version: string }>; location: string };
+    packages: Package[];
+}
+
+/**
+ * Maps package name to versions and dependents of those versions.
+ */
+export interface Dependencies {
+    [packageName: string]: {
+        [version: string]: string[];
+    };
+}
+
+/**
+ * Subset of package.json used by rules
+ */
+export interface Package {
+    cli?: CliOptions;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    exports?: string | Record<string, string | Record<string, string>> | null;
+    location: string;
+    main?: string;
+    module?: string;
+    name: string;
+    private?: boolean;
+    sideEffects?: any;
+    workspaces?: string[];
+}
+
+interface CliOptions {
+    webpack?: false | Record<string, any>;
+}
+
+export interface PackageError<T = any> {
+    data?: T;
+    details?: string | string[];
+    fixable?: FixCategory;
+    id: string;
+    location?: string;
+    message: string;
+    severity?: ErrorSeverity;
+}
+
+export enum ErrorSeverity {
+    error = 1,
+    warning = 2,
+}
+
+export enum FixCategory {
+    isolated = 'isolated', // fix examines and changes at most one dependency or package.json, if any
+    normal = 'normal', // fix potentially examines and changes multiple dependencies
+    lockFile = 'lockFile', // fix examines and changes package-lock.json
+}
+
+export interface ReviewConfiguration {
+    rules?: { [id: string]: RuleConfiguration };
+}
+
+export type RuleConfiguration = Level | [Level] | [Level, { exclude?: string[] }];
+
+export type Level = 'warn' | 'error' | 'off';