@servicetitan/startup 32.3.2 → 32.5.0

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

@@ -1,15 +1,12 @@
-import { runCommand, runCommandOutput } from '../cli-os';
+import { runCommandOutput } from '../cli-os';
 
-import { gitCloneRepo, gitGetBranch, gitGetCommitHash, gitIsReachable } from '../cli-git';
-import { isCI } from '../is-ci';
+import { gitGetBranch, gitGetCommitHash } from '../cli-git';
 
-jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
-jest.mock('../cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
+jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
 
 describe('[startup] Cli Utils (Git)', () => {
     beforeEach(() => {
-        jest.resetAllMocks();
-        jest.mocked(isCI).mockReturnValue(false);
+        jest.clearAllMocks();
     });
 
     function itRunsCommand(subject: Function, command: string) {
@@ -30,137 +27,4 @@ describe('[startup] Cli Utils (Git)', () => {
     describe(gitGetCommitHash.name, () => {
         itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
     });
-
-    describe(gitCloneRepo.name, () => {
-        const destination = 'foo';
-        const name = '{name}';
-
-        const webUrl = `https://github.com/servicetitan/${name}.git`;
-        const sshUrl = `git@github.com:servicetitan/${name}.git`;
-
-        let params: Parameters<typeof gitCloneRepo>[0];
-
-        beforeEach(() => (params = { destination, name }));
-
-        const subject = () => gitCloneRepo(params);
-
-        function itReturns(value: boolean) {
-            test(`it returns ${value}`, async () => {
-                expect(await subject()).toBe(value);
-            });
-        }
-
-        test(`clones ${sshUrl} to destination directory`, async () => {
-            await subject();
-
-            expect(runCommand).toHaveBeenCalledWith(
-                `git clone -q ${sshUrl} ${destination}`,
-                expect.anything()
-            );
-        });
-
-        itReturns(true);
-
-        describe(`when cloning ${sshUrl} fails`, () => {
-            beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
-
-            test(`clones ${webUrl} to destination directory`, async () => {
-                await subject();
-
-                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 ${webUrl} also fails`, () => {
-                beforeEach(() => {
-                    jest.mocked(runCommand).mockRejectedValue('Nope!');
-                });
-
-                itReturns(false);
-            });
-        });
-
-        describe('when running in CI environment with GITHUB_TOKEN', () => {
-            const originalEnv = process.env;
-            const token = 'foo-bar';
-
-            beforeEach(() => {
-                jest.mocked(isCI).mockReturnValue(true);
-                process.env.GITHUB_TOKEN = token;
-            });
-            afterEach(() => (process.env = originalEnv));
-
-            test(`clones ${webUrl} with token to destination directory`, async () => {
-                await subject();
-
-                const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
-                expect(runCommand).toHaveBeenCalledWith(
-                    `git clone -q ${urlWithToken} ${destination}`,
-                    expect.anything()
-                );
-            });
-        });
-    });
-
-    describe(gitIsReachable.name, () => {
-        const name = '{name}';
-
-        let params: Parameters<typeof gitIsReachable>[0];
-
-        beforeEach(() => (params = { name }));
-
-        const subject = () => gitIsReachable(params);
-
-        function itReturns(value: boolean) {
-            test(`it returns ${value}`, () => {
-                expect(subject()).toBe(value);
-            });
-        }
-
-        const webUrl = `https://github.com/servicetitan/${name}.git`;
-        const sshUrl = `git@github.com:servicetitan/${name}.git`;
-
-        test(`checks if ${sshUrl} is reachable`, () => {
-            subject();
-
-            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
-                quiet: true,
-            });
-        });
-
-        itReturns(true);
-
-        describe(`when ${sshUrl} is not reachable`, () => {
-            beforeEach(() => {
-                jest.mocked(runCommandOutput).mockImplementationOnce(() => {
-                    throw new Error('Oops!');
-                });
-            });
-
-            test(`checks if ${webUrl} is reachable`, () => {
-                subject();
-
-                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
-                    quiet: true,
-                });
-            });
-
-            itReturns(true);
-
-            describe(`when ${webUrl} is also unreachable`, () => {
-                beforeEach(() =>
-                    jest.mocked(runCommandOutput).mockImplementation(() => {
-                        throw new Error('Oops');
-                    })
-                );
-
-                itReturns(false);
-            });
-        });
-    });
 });

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

@@ -8,7 +8,6 @@ import {
     npmTagVersion,
     npmUnpublish,
     npmView,
-    npmWhoAmI,
 } from '../cli-npm';
 
 jest.mock('../cli-os', () => ({
@@ -249,46 +248,4 @@ describe('[startup] Cli Utils (Npm)', () => {
             });
         });
     });
-
-    describe(npmWhoAmI.name, () => {
-        const username = 'Foo\n';
-        let args: Parameters<typeof npmWhoAmI>[0];
-
-        beforeEach(() => {
-            args = undefined;
-            jest.mocked(runCommandOutput).mockReturnValue(username);
-        });
-
-        const subject = () => npmWhoAmI(args);
-
-        itRunsCommandOutput(subject, 'npm whoami', {
-            quiet: true,
-            stdio: ['pipe', 'pipe', 'ignore'],
-            timeout: 10000,
-        });
-
-        test('returns trimmed username ', () => {
-            expect(subject()).toEqual(username.trim());
-        });
-
-        describe('with registry', () => {
-            beforeEach(() => (args = { registry: '{registry}' }));
-
-            itRunsCommandOutput(subject, 'npm whoami --registry={registry}', expect.anything());
-        });
-
-        describe('when command fails', () => {
-            const error = new Error('Oops');
-
-            beforeEach(() => {
-                jest.mocked(runCommandOutput).mockImplementation(() => {
-                    throw error;
-                });
-            });
-
-            test('ignores error and returns undefined', () => {
-                expect(subject()).toBeUndefined();
-            });
-        });
-    });
 });

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -1,12 +1,12 @@
+import { isCI } from '@servicetitan/install';
 import execa from 'execa';
 
 import { log } from '../../../utils';
-import { isCI } from '../is-ci';
 import { maybeCreateGitFolder } from '../maybe-create-git-folder';
 import { lernaExec } from '../lerna-exec';
 
+jest.mock('@servicetitan/install');
 jest.mock('execa');
-jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
 jest.mock('../maybe-create-git-folder', () => ({ maybeCreateGitFolder: jest.fn() }));
 
 const AVAILABLE_PARALLELISM = 2;

package/src/cli/utils/__tests__/stylelint.test.ts

@@ -0,0 +1,164 @@
+import { lint } from 'stylelint';
+import { stylelint } from '../stylelint';
+import { getDestinationFolders, getStylelintConfiguration } from '../../../utils';
+
+jest.mock('stylelint', () => ({ lint: jest.fn() }));
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getDestinationFolders: jest.fn(),
+    getStylelintConfiguration: jest.fn(),
+}));
+
+describe(`[startup] utils:${stylelint.name}`, () => {
+    const defaultFiles = '**/*.{css,scss,less}';
+    let args: Parameters<typeof stylelint>[0];
+    let linterResult: Partial<Awaited<ReturnType<typeof lint>>>;
+    let writeSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        args = {};
+        linterResult = { report: 'report' };
+
+        jest.clearAllMocks();
+        jest.mocked(getDestinationFolders).mockReturnValue([]);
+        jest.mocked(getStylelintConfiguration).mockReturnValue({});
+        jest.mocked(lint).mockImplementation(() => Promise.resolve(linterResult) as any);
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+    });
+
+    const subject = async () => stylelint(args);
+
+    test('runs linter', async () => {
+        await subject();
+
+        expect(lint).toHaveBeenCalledWith(
+            expect.objectContaining({
+                files: [defaultFiles],
+                formatter: 'string',
+                ignorePattern: ['node_modules'],
+            })
+        );
+    });
+
+    test('outputs report', async () => {
+        await subject();
+
+        expect(writeSpy).toHaveBeenCalledWith(linterResult.report);
+    });
+
+    describe('with output folders', () => {
+        const outputFolders = ['../foo/out/', 'dist/', 'packages/bar/out/', 'packages/foo/dist/'];
+
+        beforeEach(() => jest.mocked(getDestinationFolders).mockReturnValue(outputFolders));
+
+        test('ignores output folders', async () => {
+            await subject();
+
+            expect(lint).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    ignorePattern: ['node_modules', ...outputFolders],
+                })
+            );
+        });
+    });
+
+    describe('with {fix: true}', () => {
+        beforeEach(() => (args.fix = true));
+
+        test('applies fixes', async () => {
+            await subject();
+
+            expect(lint).toHaveBeenCalledWith(expect.objectContaining({ fix: true }));
+        });
+    });
+
+    describe('with directory paths', () => {
+        beforeEach(() => (args.paths = ['packages/foo', 'packages/bar']));
+
+        test('appends glob pattern to path', async () => {
+            await subject();
+
+            expect(lint).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    files: args.paths!.map(path => `${path}/${defaultFiles}`),
+                })
+            );
+        });
+    });
+
+    describe('with file paths', () => {
+        const allowedPaths = ['foo.css', 'bar.scss', 'baz.less'];
+
+        beforeEach(() => (args.paths = allowedPaths));
+
+        test('passes paths to linter', async () => {
+            await subject();
+
+            expect(lint).toHaveBeenCalledWith(expect.objectContaining({ files: args.paths }));
+        });
+
+        describe('with disallowed paths', () => {
+            const disallowedPaths = ['foo.txt', 'bar.*'];
+
+            beforeEach(() => (args.paths = [...allowedPaths, ...disallowedPaths]));
+
+            test('ignores disallowed paths', async () => {
+                await subject();
+
+                expect(lint).toHaveBeenCalledWith(expect.objectContaining({ files: allowedPaths }));
+            });
+            describe('with only disallowed paths', () => {
+                beforeEach(() => (args.paths = disallowedPaths));
+
+                test('ignores paths', async () => {
+                    await subject();
+
+                    expect(lint).toHaveBeenCalledWith(
+                        expect.objectContaining({ files: [defaultFiles] })
+                    );
+                });
+            });
+        });
+    });
+
+    describe('when there are errors', () => {
+        const exitCode = process.exitCode;
+
+        beforeEach(() => (linterResult.errored = true));
+
+        afterAll(() => (process.exitCode = exitCode));
+
+        test('sets process.exitCode', async () => {
+            await subject();
+
+            expect(process.exitCode).toBeGreaterThan(0);
+        });
+    });
+
+    describe('when disabled', () => {
+        beforeEach(() => {
+            jest.mocked(getStylelintConfiguration).mockReturnValue({ disabled: true });
+        });
+
+        test('does nothing', async () => {
+            await subject();
+
+            expect(lint).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('with custom config', () => {
+        const config: ReturnType<typeof getStylelintConfiguration> = { ignorePath: 'foo' };
+
+        beforeEach(() => {
+            jest.mocked(getStylelintConfiguration).mockReturnValue(config);
+        });
+
+        test('passes config to linter', async () => {
+            await subject();
+
+            expect(lint).toHaveBeenCalledWith(expect.objectContaining(config));
+        });
+    });
+});

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

@@ -1,6 +1,4 @@
-import { log } from '../../utils';
-import { runCommand, runCommandOutput } from './cli-os';
-import { isCI } from './is-ci';
+import { runCommandOutput } from './cli-os';
 
 export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
@@ -9,52 +7,3 @@ export function gitGetBranch(): string {
 export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
 }
-
-interface Repo {
-    owner?: string;
-    name: string;
-}
-
-export async function gitCloneRepo(params: Repo & { destination: string }) {
-    const { destination, name, owner = 'servicetitan' } = params;
-    const gitUrls = getGitUrls({ owner, name });
-
-    for (const url of gitUrls) {
-        try {
-            const command = `git clone -q ${url} ${destination}`;
-            log.debug('git:clone-repo', `running ${command}`);
-
-            // eslint-disable-next-line no-await-in-loop
-            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
-        }
-    }
-
-    return false;
-}
-
-export function gitIsReachable({ owner = 'servicetitan', name }: Repo) {
-    return getGitUrls({ owner, name }).some(url => {
-        try {
-            runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
-            return true;
-        } catch {
-            return false;
-        }
-    });
-}
-
-function getGitUrls({ owner, name }: Repo) {
-    const webUrl = `https://github.com/${owner}/${name}.git`;
-    const sshUrl = `git@github.com:${owner}/${name}.git`;
-
-    return isCI() && !!process.env.GITHUB_TOKEN
-        ? [webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)]
-        : [sshUrl, webUrl];
-}

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

@@ -95,15 +95,3 @@ export function npmView({ packageName, registry }: { packageName: string; regist
         // 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/index.ts

@@ -9,7 +9,6 @@ export * from './compile-sass';
 export * from './copy-files';
 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';
@@ -18,6 +17,7 @@ export * from './pipe-stdout';
 export * from './process-tree';
 export * from './publish';
 export * from './set-node-options';
+// Don't export ./stylelint, it breaks tests using the default "jsdom" environment
 export * from './ts-config';
 export * from './type-check';
 export * from './watch-stdout';

package/src/cli/utils/lerna-exec.ts

@@ -1,8 +1,8 @@
+import { isCI } from '@servicetitan/install';
 import execa, { StdioOption } from 'execa';
 import os from 'node:os';
 
 import { log } from '../../utils';
-import { isCI } from './is-ci';
 import { maybeCreateGitFolder } from './maybe-create-git-folder';
 
 interface Args {

package/src/cli/utils/stylelint.ts

@@ -0,0 +1,55 @@
+import path from 'path';
+import { lint } from 'stylelint';
+import { CommandArgs } from '../commands';
+import { getDestinationFolders, getStylelintConfiguration, log } from '../../utils';
+
+interface Args extends CommandArgs {
+    fix?: boolean;
+    paths?: string[];
+}
+
+const allowedExtensions = ['css', 'scss', 'less'];
+const glob = `**/*.{${allowedExtensions.join(',')}}`;
+
+export async function stylelint({ fix, paths = [] }: Args) {
+    const { disabled, ...config } = getStylelintConfiguration();
+    if (disabled) {
+        return;
+    }
+
+    const files = paths.reduce<string[]>((result, file) => {
+        const extension = path.parse(file).ext.slice(1); // drop leading dot
+        if (extension) {
+            if (allowedExtensions.includes(extension.toLowerCase())) {
+                result.push(file);
+            } else {
+                log.debug('stylelint', `ignoring ${file}`);
+            }
+        } else {
+            result.push(pathUniJoin(file, glob));
+        }
+        return result;
+    }, []);
+
+    const options: Parameters<typeof lint>[0] = {
+        files: files.length ? files : [glob],
+        ignorePattern: ['node_modules', ...getDestinationFolders()],
+        formatter: 'string',
+        fix,
+        quietDeprecationWarnings: true,
+        ...config,
+    };
+
+    /* istanbul ignore next: debug only */
+    log.debug('stylelint', () => JSON.stringify(options, null, 2));
+
+    const { report, errored } = await lint(options);
+    process.stdout.write(report);
+    if (errored) {
+        process.exitCode = 1;
+    }
+}
+
+function pathUniJoin(...chunks: string[]) {
+    return path.join(...chunks).replace(/\\/g, '/');
+}

package/src/utils/get-configuration.ts

@@ -78,6 +78,7 @@ export enum CommandName {
     'prepare-package' = 'prepare-package',
     'review' = 'review',
     'start' = 'start',
+    'stylelint' = 'stylelint',
     'styles-check' = 'styles-check',
     'test' = 'test',
     'task' = 'task',

package/dist/cli/utils/is-ci.d.ts

@@ -1,2 +0,0 @@
-export declare function isCI(): boolean;
-//# sourceMappingURL=is-ci.d.ts.map

package/dist/cli/utils/is-ci.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-ci.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/is-ci.ts"],"names":[],"mappings":"AAAA,wBAAgB,IAAI,YAEnB"}

package/dist/cli/utils/is-ci.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "isCI", {
-    enumerable: true,
-    get: function() {
-        return isCI;
-    }
-});
-function isCI() {
-    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;
-}
-
-//# sourceMappingURL=is-ci.js.map

package/dist/cli/utils/is-ci.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cli/utils/is-ci.ts"],"sourcesContent":["export function isCI() {\n    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;\n}\n"],"names":["isCI","process","env","CI","TEAMCITY_VERSION"],"mappings":";;;;+BAAgBA;;;eAAAA;;;AAAT,SAASA;IACZ,OAAO,CAAC,CAACC,QAAQC,GAAG,CAACC,EAAE,IAAI,CAAC,CAACF,QAAQC,GAAG,CAACE,gBAAgB;AAC7D"}

package/src/cli/utils/__tests__/is-ci.test.ts

@@ -1,40 +0,0 @@
-import { isCI } from '../is-ci';
-
-describe(`[startup] Utils ${isCI.name}`, () => {
-    const originalCI = process.env.CI;
-
-    beforeAll(() => delete process.env.CI);
-    afterAll(() => (process.env.CI = originalCI));
-
-    const subject = () => isCI();
-
-    function itReturns(value: boolean) {
-        test(`returns ${value}`, () => {
-            expect(subject()).toBe(value);
-        });
-    }
-
-    itReturns(false);
-
-    describe.each([
-        { value: '', result: false },
-        { value: '1', result: true },
-    ])('when process.env.CI is "$value"', ({ value, result }) => {
-        beforeEach(() => (process.env.CI = value));
-
-        afterEach(() => delete process.env.CI);
-
-        itReturns(result);
-    });
-
-    describe.each([
-        { value: '', result: false },
-        { value: '1', result: true },
-    ])('when process.env.TEAMCITY_VERSION is "$value"', ({ value, result }) => {
-        beforeEach(() => (process.env.TEAMCITY_VERSION = value));
-
-        afterEach(() => delete process.env.TEAMCITY_VERSION);
-
-        itReturns(result);
-    });
-});

package/src/cli/utils/is-ci.ts

@@ -1,3 +0,0 @@
-export function isCI() {
-    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;
-}