@servicetitan/startup 32.0.1 → 32.1.0

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

@@ -1,26 +1,26 @@
 import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
-import { applyFilter, isLibrary } from '../utils';
+import { checkPackages, 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[]);
+    run(project: Project): PackageError[] {
+        return checkPackages(this, project, this.checkSideEffects);
     }
 
+    private readonly checkSideEffects = (pkg: Package) => {
+        if (this.needsSideEffects(pkg)) {
+            return {
+                id: this.id,
+                message: `package "${pkg.name}" omits sideEffects property`,
+                severity: ErrorSeverity.warning,
+                location: pkg.location,
+            };
+        }
+    };
+
     private needsSideEffects(pkg: Package) {
         return (
             isLibrary(pkg) &&

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

@@ -132,9 +132,7 @@ export class RequireOneCollectionVersion implements PackageRule {
         return new Set(
             Object.entries(versions)
                 .slice(1)
-                .flatMap(([_version, dependencies]) =>
-                    Object.entries(dependencies).map(([pkg]) => pkg)
-                )
+                .flatMap(([_version, dependencies]) => Object.keys(dependencies))
         );
     }
 

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

@@ -65,15 +65,11 @@ export class RequireProjectVersionInRootNodeModules implements PackageRule {
         /* 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' })
-        );
+        [
+            ...entries.map(([name, version]) => `npm pkg set dependencies["${name}"]="${version}"`),
+            'npx startup install --fix --quiet',
+            ...entries.map(([name]) => `npm pkg delete dependencies["${name}"]`),
+        ].forEach(command => execSync(command, { stdio: 'inherit' }));
     }
 
     private formatDetails(mismatches: Mismatch[]) {

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

@@ -1,26 +1,26 @@
 import { ErrorSeverity, Package, PackageError, PackageRule, Project } from '../types';
-import { applyFilter, isLibrary } from '../utils';
+import { checkPackages, 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[]);
+    run(project: Project): PackageError[] {
+        return checkPackages(this, project, this.checkScope);
     }
 
+    private readonly checkScope = (pkg: Package) => {
+        if (this.needsScope(pkg)) {
+            return {
+                id: this.id,
+                message: `package "${pkg.name}" should have @servicetitan scope`,
+                severity: ErrorSeverity.warning,
+                location: pkg.location,
+            };
+        }
+    };
+
     private needsScope(pkg: Package) {
         return isLibrary(pkg) && pkg.private !== true && !pkg.name.startsWith('@servicetitan/');
     }

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

@@ -8,7 +8,17 @@ export interface Project {
     config: ReviewConfiguration;
     dependencies: Dependencies;
     // Only using this subset of package-lock.json
-    packageLock: { packages: Record<string, { version: string }>; location: string };
+    packageLock: {
+        packages: Record<
+            string,
+            {
+                version: string;
+                dependencies?: Record<string, string>;
+                peerDependencies?: Record<string, string>;
+            }
+        >;
+        location: string;
+    };
     packages: Package[];
 }
 
@@ -33,6 +43,7 @@ export interface Package {
     main?: string;
     module?: string;
     name: string;
+    peerDependencies?: Record<string, string>;
     private?: boolean;
     sideEffects?: any;
     workspaces?: string[];
@@ -67,6 +78,9 @@ export interface ReviewConfiguration {
     rules?: { [id: string]: RuleConfiguration };
 }
 
-export type RuleConfiguration = Level | [Level] | [Level, { exclude?: string[] }];
+export type RuleConfiguration =
+    | Level
+    | [Level]
+    | [Level, { exclude?: string[] | Record<string, string[]> }];
 
 export type Level = 'warn' | 'error' | 'off';

package/src/cli/commands/review/utils/check-packages.ts

@@ -0,0 +1,19 @@
+import { Package, PackageError, Project } from '../types';
+import { applyFilter } from './apply-filter';
+
+type CheckFn<T> = (pkg: Package) => PackageError<T>[] | PackageError<T> | undefined;
+
+export function checkPackages<T>(
+    { id }: { id?: string },
+    { config, packages }: Project,
+    fn: CheckFn<T>
+) {
+    const ruleConfig = id ? config.rules?.[id] : undefined;
+    return applyFilter(ruleConfig, packages, ({ name }) => name).reduce((result, pkg) => {
+        const error = fn(pkg);
+        if (Array.isArray(error)) {
+            return [...result, ...error];
+        }
+        return error ? [...result, error] : result;
+    }, []);
+}

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

@@ -1,4 +1,5 @@
 export * from './apply-filter';
+export * from './check-packages';
 export * from './collate-dependencies';
 export * from './compare-version';
 export * from './format-depends-on';

package/src/cli/utils/__tests__/cli-git.test.ts

@@ -50,31 +50,33 @@ describe('[startup] Cli Utils (Git)', () => {
             });
         }
 
-        test(`clones ${webUrl} to destination directory`, async () => {
+        test(`clones ${sshUrl} to destination directory`, async () => {
             await subject();
 
-            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
-                quiet: true,
-            });
+            expect(runCommand).toHaveBeenCalledWith(
+                `git clone -q ${sshUrl} ${destination}`,
+                expect.anything()
+            );
         });
 
         itReturns(true);
 
-        describe(`when cloning ${webUrl} fails`, () => {
+        describe(`when cloning ${sshUrl} fails`, () => {
             beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
 
-            test(`clones ${sshUrl} to destination directory`, async () => {
+            test(`clones ${webUrl} to destination directory`, async () => {
                 await subject();
 
-                expect(runCommand).toHaveBeenCalledWith(
-                    `git clone -q ${sshUrl} ${destination}`,
-                    expect.anything()
-                );
+                expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                    quiet: true,
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    env: expect.objectContaining({ GIT_TERMINAL_PROMPT: '0' }),
+                });
             });
 
             itReturns(true);
 
-            describe(`when cloning ${sshUrl} also fails`, () => {
+            describe(`when cloning ${webUrl} also fails`, () => {
                 beforeEach(() => {
                     jest.mocked(runCommand).mockRejectedValue('Nope!');
                 });
@@ -93,7 +95,7 @@ describe('[startup] Cli Utils (Git)', () => {
             });
             afterEach(() => (process.env = originalEnv));
 
-            test(`adds token to ${webUrl}`, async () => {
+            test(`clones ${webUrl} with token to destination directory`, async () => {
                 await subject();
 
                 const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
@@ -123,34 +125,34 @@ describe('[startup] Cli Utils (Git)', () => {
         const webUrl = `https://github.com/servicetitan/${name}.git`;
         const sshUrl = `git@github.com:servicetitan/${name}.git`;
 
-        test(`checks if ${webUrl} is reachable`, () => {
+        test(`checks if ${sshUrl} is reachable`, () => {
             subject();
 
-            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
                 quiet: true,
             });
         });
 
         itReturns(true);
 
-        describe(`when ${webUrl} is not reachable`, () => {
+        describe(`when ${sshUrl} is not reachable`, () => {
             beforeEach(() => {
                 jest.mocked(runCommandOutput).mockImplementationOnce(() => {
                     throw new Error('Oops!');
                 });
             });
 
-            test(`checks if ${sshUrl} is reachable`, () => {
+            test(`checks if ${webUrl} is reachable`, () => {
                 subject();
 
-                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
                     quiet: true,
                 });
             });
 
             itReturns(true);
 
-            describe(`when ${sshUrl} is also unreachable`, () => {
+            describe(`when ${webUrl} is also unreachable`, () => {
                 beforeEach(() =>
                     jest.mocked(runCommandOutput).mockImplementation(() => {
                         throw new Error('Oops');

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

@@ -25,7 +25,11 @@ export async function gitCloneRepo(params: Repo & { destination: string }) {
             log.debug('git:clone-repo', `running ${command}`);
 
             // eslint-disable-next-line no-await-in-loop
-            await runCommand(command, { quiet: true });
+            await runCommand(command, {
+                quiet: true,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+            });
             return true;
         } catch {
             // ignore error
@@ -50,10 +54,7 @@ function getGitUrls({ owner, name }: Repo) {
     const webUrl = `https://github.com/${owner}/${name}.git`;
     const sshUrl = `git@github.com:${owner}/${name}.git`;
 
-    const urls = [webUrl, sshUrl];
-    if (isCI() && !!process.env.GITHUB_TOKEN) {
-        urls.unshift(webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`));
-    }
-
-    return urls;
+    return isCI() && !!process.env.GITHUB_TOKEN
+        ? [webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)]
+        : [sshUrl, webUrl];
 }