@servicetitan/startup 24.0.4 → 24.1.1

package/src/utils/__tests__/get-packages.test.ts

@@ -1,7 +1,5 @@
-import execa from 'execa';
-import { isBundle, isLegacy } from '../get-configuration';
-import { maybeCreateGitFolder } from '../maybe-create-git-folder';
-
+import path from 'path';
+import { fs, vol } from 'memfs';
 import {
     Package,
     PackageType,
@@ -10,142 +8,222 @@ import {
     splitPackagesByType,
 } from '../get-packages';
 
-jest.mock('execa', () => ({ sync: jest.fn() }));
-jest.mock('../get-configuration');
-jest.mock('../maybe-create-git-folder');
+jest.mock('fs', () => fs);
 
 describe('[startup] Utils', () => {
-    const packages: Pick<Package, 'name' | 'location' | 'type'>[] = [
-        { name: 'foo', location: 'packages/foo', type: PackageType.Legacy },
-        { name: 'bar', location: 'packages/bar', type: PackageType.TSC },
-        { name: 'baz', location: 'packages/baz', type: PackageType.Webpack },
-    ];
+    beforeEach(() => jest.clearAllMocks());
 
     describe(`${getPackages.name}`, () => {
         let options: Parameters<typeof getPackages>[0] | undefined;
-        let dependencies: Record<string, string[]> | undefined;
-
-        function findPackageByLocation(location?: string) {
-            return packages.find(p => p.location === location);
-        }
-
-        function packageGraph() {
-            return dependencies ?? Object.fromEntries(packages.map(({ name }) => [name, []]));
-        }
-
-        function scopedPackages() {
-            let result = packages;
-            if (options?.scope) {
-                const arrayScope = Array.isArray(options.scope) ? options.scope : [options.scope];
-                result = result.filter(({ name }) => arrayScope.includes(name));
-            }
-            return result;
-        }
-
-        function resolvePackages(args: string[]) {
-            if (args.includes('--graph')) {
-                return packageGraph();
-            }
-            if (args.includes('--scope')) {
-                return scopedPackages().map(({ type, ...pkg }) => pkg);
-            }
-            return packages.map(({ type, ...pkg }) => pkg);
-        }
 
         beforeEach(() => {
             options = undefined;
-            dependencies = undefined;
-
-            jest.mocked(isBundle).mockImplementation(
-                location => findPackageByLocation(location)?.type === PackageType.Webpack
-            );
-            jest.mocked(isLegacy).mockImplementation(
-                location => findPackageByLocation(location)?.type === PackageType.Legacy
-            );
-            // @ts-expect-error because implementation doesn't match all exec.sync signatures
-            jest.mocked(execa.sync).mockImplementation((_: string, args: string[]): any => {
-                return { stdout: JSON.stringify(resolvePackages(args)) };
+            vol.fromNestedJSON({
+                'package.json': JSON.stringify({
+                    workspaces: ['packages/*', 'examples/*', 'legacy/bar'],
+                }),
+                'packages': {
+                    foo: {
+                        'package.json': JSON.stringify({
+                            name: 'foo',
+                            version: '1.0.0',
+                            private: true,
+                        }),
+                    },
+                },
+                'legacy': {
+                    bar: {
+                        'package.json': JSON.stringify({
+                            name: 'bar',
+                            version: '2.0.0',
+                            cli: { legacy: true },
+                        }),
+                    },
+                },
+                'examples': {
+                    baz: {
+                        'package.json': JSON.stringify({
+                            name: 'baz',
+                            version: '3.0.0',
+                            cli: { webpack: false },
+                        }),
+                    },
+                },
             });
         });
 
-        const subject = () => getPackages(options);
-
-        test('returns lerna packages with type metadata', () => {
-            expect(subject()).toEqual(packages);
-            expect(execa.sync).toHaveBeenCalledWith('npx', 'lerna la --json'.split(' '));
+        afterEach(() => vol.reset());
+
+        const subject = () =>
+            getPackages(options).sort((a, b) => a.version.localeCompare(b.version));
+
+        test('returns workspace packages', () => {
+            expect(subject()).toEqual([
+                {
+                    name: 'foo',
+                    version: '1.0.0',
+                    private: true,
+                    location: path.resolve('./packages/foo'),
+                    type: PackageType.Webpack,
+                },
+                {
+                    name: 'bar',
+                    version: '2.0.0',
+                    private: false,
+                    location: path.resolve('./legacy/bar'),
+                    type: PackageType.Legacy,
+                },
+                {
+                    name: 'baz',
+                    version: '3.0.0',
+                    private: false,
+                    location: path.resolve('./examples/baz'),
+                    type: PackageType.TSC,
+                },
+            ]);
         });
 
-        test('conditionally creates .git folder', () => {
-            subject();
+        describe('with "scope"', () => {
+            beforeEach(() => (options = { scope: 'foo' }));
 
-            expect(maybeCreateGitFolder).toHaveBeenCalled();
-        });
+            test('returns only the specified packages', () => {
+                expect(subject()).toEqual([expect.objectContaining({ name: 'foo' })]);
+            });
 
-        describe.each(['scope', 'ignore'])('with "%s"', option => {
-            beforeEach(() => (options = { [option]: 'foo' }));
+            describe('when filtered package has dependencies', () => {
+                beforeEach(() => {
+                    const fooPath = path.resolve('./packages/foo/package.json');
+                    const fooJson = JSON.parse(fs.readFileSync(fooPath, 'utf8').toString());
+                    fs.writeFileSync(
+                        fooPath,
+                        JSON.stringify({ ...fooJson, dependencies: { bar: '>=2.0' } })
+                    );
+                });
+
+                test('also returns internal dependencies', () => {
+                    expect(subject()).toEqual([
+                        expect.objectContaining({ name: 'foo' }),
+                        expect.objectContaining({ name: 'bar' }),
+                    ]);
+                });
+            });
 
-            test(`passes "${option}" option to lerna`, () => {
-                subject();
+            describe('when "scope" is a glob expression', () => {
+                beforeEach(() => (options = { scope: 'ba*' }));
 
-                expect(execa.sync).toHaveBeenCalledWith(
-                    'npx',
-                    `lerna la --${option} foo --json`.split(' ')
-                );
+                test('returns only the specified packages', () => {
+                    expect(subject()).toEqual([
+                        expect.objectContaining({ name: 'bar' }),
+                        expect.objectContaining({ name: 'baz' }),
+                    ]);
+                });
             });
         });
 
-        describe('with "scope"', () => {
-            beforeEach(() => (options = { scope: 'foo' }));
+        describe('with "ignore"', () => {
+            beforeEach(() => (options = { ignore: ['foo'] }));
 
-            test('returns filtered packages', () => {
-                expect(subject()).toEqual(packages.filter(({ name }) => name === 'foo'));
+            test('omits the specified packages', () => {
+                expect(subject()).not.toContainEqual(expect.objectContaining({ name: 'foo' }));
             });
 
-            describe('when filtered package has dependencies', () => {
-                beforeEach(() => (dependencies = { ...packageGraph(), foo: ['bar', 'external'] }));
+            describe('when "ignore" is a glob expression', () => {
+                beforeEach(() => (options = { ignore: ['ba*'] }));
 
-                test('also returns internal dependencies', () => {
-                    expect(subject()).toEqual(
-                        packages.filter(({ name }) => ['foo', 'bar'].includes(name))
-                    );
+                test('returns only the specified packages', () => {
+                    const result = subject();
+                    expect(result).not.toContainEqual(expect.objectContaining({ name: 'bar' }));
+                    expect(result).not.toContainEqual(expect.objectContaining({ name: 'baz' }));
                 });
             });
         });
+
+        function itReturnsEmptyArray() {
+            test('returns empty array', () => {
+                expect(subject()).toEqual([]);
+            });
+        }
+
+        describe('with no packages', () => {
+            beforeEach(() => vol.fromJSON({ 'package.json': JSON.stringify({}) }));
+
+            itReturnsEmptyArray();
+        });
+
+        describe('with no package.json', () => {
+            beforeEach(() => vol.reset());
+
+            itReturnsEmptyArray();
+        });
     });
 
     describe(`${getPackagesGraph.name}`, () => {
-        const packageGraph = Object.fromEntries(packages.map(({ name }) => [name, []]));
         let options: Parameters<typeof getPackagesGraph>[0] | undefined;
 
         beforeEach(() => {
             options = undefined;
-            jest.mocked(execa.sync).mockImplementation((): any => ({
-                stdout: JSON.stringify(packageGraph),
-            }));
+            vol.fromNestedJSON({
+                'package.json': JSON.stringify({ workspaces: ['packages/*'] }),
+                'packages': {
+                    foo: {
+                        'package.json': JSON.stringify({
+                            name: 'foo',
+                            dependencies: { bar: '^1.0.0', react: '>=18' },
+                            devDependencies: {
+                                '@testing-library/react': '>=16',
+                                '@testing-library/dom': '>=10',
+                            },
+                        }),
+                    },
+                    bar: {
+                        'package.json': JSON.stringify({
+                            name: 'bar',
+                            dependencies: { foo: '*' },
+                        }),
+                    },
+                    baz: {
+                        'package.json': JSON.stringify({
+                            name: 'baz',
+                        }),
+                    },
+                },
+            });
         });
 
         const subject = () => getPackagesGraph(options);
 
-        test('returns lerna package graph', () => {
-            expect(subject()).toEqual(packageGraph);
-            expect(execa.sync).toHaveBeenCalledWith('npx', 'lerna la --graph'.split(' '));
+        test('returns package graph', () => {
+            expect(subject()).toEqual({
+                foo: ['bar', 'react', '@testing-library/react', '@testing-library/dom'].sort(),
+                bar: ['foo'],
+                baz: [],
+            });
         });
 
-        describe.each(['scope', 'ignore'])('with "%s"', option => {
-            beforeEach(() => (options = { [option]: 'foo' }));
+        describe('with "scope"', () => {
+            beforeEach(() => (options = { scope: 'foo' }));
+
+            test('includes only the specified packages', () => {
+                expect(Object.keys(subject())).toEqual(['foo']);
+            });
+        });
 
-            test(`passes "${option}" option to lerna`, () => {
-                subject();
+        describe('with "ignore"', () => {
+            beforeEach(() => (options = { ignore: ['foo', 'bar'] }));
 
-                expect(execa.sync).toHaveBeenCalledWith(
-                    'npx',
-                    `lerna la --${option} foo --graph`.split(' ')
-                );
+            test('omits the specified packages', () => {
+                expect(Object.keys(subject())).toEqual(['baz']);
             });
         });
     });
 
     describe(`${splitPackagesByType.name}`, () => {
+        const packages: Pick<Package, 'name' | 'location' | 'type'>[] = [
+            { name: 'foo', location: 'packages/foo', type: PackageType.Legacy },
+            { name: 'bar', location: 'packages/bar', type: PackageType.TSC },
+            { name: 'baz', location: 'packages/baz', type: PackageType.Webpack },
+        ];
+
         const subject = (packages: Package[]) => splitPackagesByType(packages);
 
         test('groups packages by type', () => {

package/src/utils/find-packages.ts

@@ -0,0 +1,61 @@
+import { globSync } from 'glob';
+import path from 'path';
+import { readJsonSafe } from './read-json';
+import { log } from './log';
+
+export interface ProjectPackage extends Record<string, any> {
+    name: string;
+    location: string;
+}
+
+export function findPackages(): ProjectPackage[] {
+    const workspaces = findWorkspaces();
+    if (!workspaces) {
+        return [];
+    }
+
+    const result = workspaces
+        .flatMap(pattern => globSync(pattern))
+        .map(location => {
+            const dir = path.resolve(location);
+            const file = path.join(dir, 'package.json');
+            return { ...readJsonSafe<ProjectPackage>(file), location: dir };
+        })
+        .filter(({ name }) => name !== undefined) as ProjectPackage[];
+
+    /* istanbul ignore next: debug only */
+    log.debug(
+        `find-packages`,
+        () => `found packages: ${JSON.stringify(result.map(({ name }) => name))}`
+    );
+
+    return result;
+}
+
+function findWorkspaces() {
+    let directory = path.resolve('./');
+    do {
+        const packageJson = path.resolve(path.join(directory, 'package.json'));
+
+        log.debug('find-packages', `reading: ${packageJson}`);
+        let workspaces = readJsonSafe<{ workspaces: string[] }>(packageJson)?.workspaces;
+
+        if (!workspaces) {
+            const lernaJson = path.resolve(path.join(directory, 'lerna.json'));
+            log.debug('find-packages', `reading: ${lernaJson}`);
+            workspaces = readJsonSafe<{ packages: string[] }>(lernaJson)?.packages;
+        }
+
+        if (workspaces) {
+            workspaces = workspaces.map(
+                // Note, glob requires "/" as path separator, even on Windows
+                workspace => path.join(directory, workspace).replace(/\\/g, '/')
+            );
+            /* istanbul ignore next: debug only */
+            log.debug('find-packages', () => `found workspaces: ${JSON.stringify(workspaces)}`);
+            return workspaces;
+        }
+
+        directory = path.resolve(path.join(directory, '../'));
+    } while (path.parse(directory).name);
+}

package/src/utils/get-configuration.ts

@@ -71,12 +71,22 @@ type Configuration = {
     [key in CommandName]: NodeConfiguration;
 } & NodeConfiguration;
 
-export function getConfiguration(location = './'): Configuration {
-    return readJson(path.join(location, 'package.json')).cli ?? {};
+type LocationOrJson = string | Record<string, any>;
+
+export function getConfiguration(locationOrJson: LocationOrJson = './'): Configuration {
+    const json =
+        typeof locationOrJson === 'string'
+            ? readJson(path.join(locationOrJson, 'package.json'))
+            : locationOrJson;
+    return json?.cli ?? {};
 }
 
-export function getConfigurationSafe(location = './'): Configuration {
-    return readJsonSafe(path.join(location, 'package.json'))?.cli ?? {};
+export function getConfigurationSafe(locationOrJson: LocationOrJson = './'): Configuration {
+    const json =
+        typeof locationOrJson === 'string'
+            ? readJsonSafe(path.join(locationOrJson, 'package.json'))
+            : locationOrJson;
+    return json?.cli ?? {};
 }
 
 export function getDevServerConfiguration() {
@@ -114,8 +124,8 @@ export function getStylelintConfiguration() {
     return getConfiguration().lint?.stylelint ?? {};
 }
 
-export function isBundle(location?: string) {
-    return getConfiguration(location).webpack !== false;
+export function isBundle(locationOrJson?: LocationOrJson) {
+    return getConfiguration(locationOrJson).webpack !== false;
 }
 
 export function isCustomStyleRules() {
@@ -138,8 +148,8 @@ export function isExposeSharedDependencies() {
     return configuration.webpack['expose-shared-dependencies'] === true;
 }
 
-export function isLegacy(location?: string) {
-    return getConfiguration(location).legacy === true;
+export function isLegacy(locationOrJson?: LocationOrJson) {
+    return getConfiguration(locationOrJson).legacy === true;
 }
 
 export function isLegacyRoot() {

package/src/utils/get-packages.ts

@@ -1,6 +1,6 @@
-import execa from 'execa';
+import multimatch from 'multimatch';
+import { findPackages, ProjectPackage } from './find-packages';
 import { isBundle, isLegacy } from './get-configuration';
-import { maybeCreateGitFolder } from './maybe-create-git-folder';
 import { toArray } from './to-array';
 
 export enum PackageType {
@@ -17,8 +17,6 @@ export interface Package {
     location: string;
 }
 
-type RawPackage = Omit<Package, 'type'>;
-
 interface GetPackagesOptions {
     scope?: string | string[];
     ignore?: string | string[];
@@ -28,26 +26,13 @@ export function getPackages(options: GetPackagesOptions = {}) {
     const scope = toArray(options.scope);
     const ignore = toArray(options.ignore);
 
-    maybeCreateGitFolder();
-    const allPackages: RawPackage[] = JSON.parse(
-        execa.sync('npx', ['lerna', 'la', '--json']).stdout
-    );
-
-    if (!scope.length && !ignore.length) {
+    const allPackages = findPackages();
+    if (scope.length === 0 && ignore.length === 0) {
         return withMetadata(allPackages);
     }
 
-    const filteredPackages: RawPackage[] = JSON.parse(
-        execa.sync('npx', [
-            'lerna',
-            'la',
-            ...scope.map(v => ['--scope', v]).flat(),
-            ...ignore.map(v => ['--ignore', v]).flat(),
-            '--json',
-        ]).stdout
-    );
-
-    const graph: Record<string, string[]> = getPackagesGraph();
+    const filteredPackages = filterPackages(allPackages, options);
+    const graph = buildPackageGraph(allPackages);
 
     // We don't need external dependencies
     for (const [vertex, dependencies] of Object.entries(graph)) {
@@ -77,39 +62,67 @@ export function getPackages(options: GetPackagesOptions = {}) {
     return withMetadata(allPackages.filter(({ name }) => used[name]));
 }
 
-interface GetPackagesGraphOptions {
-    scope?: string | string[];
-    ignore?: string | string[];
-}
-
 /**
  * Returns packages and their direct dependencies
  */
-export function getPackagesGraph(options: GetPackagesGraphOptions = {}): Record<string, string[]> {
-    const scope = toArray(options.scope);
-    const ignore = toArray(options.ignore);
+export function getPackagesGraph(options: GetPackagesOptions = {}) {
+    return buildPackageGraph(filterPackages(findPackages(), options));
+}
 
-    return JSON.parse(
-        execa.sync('npx', [
-            'lerna',
-            'la',
-            ...scope.map(v => ['--scope', v]).flat(),
-            ...ignore.map(v => ['--ignore', v]).flat(),
-            '--graph',
-        ]).stdout
+function buildPackageGraph(packages: ProjectPackage[]) {
+    return packages.reduce<Record<string, string[]>>(
+        (result, { name, dependencies = {}, devDependencies = {} }) => {
+            result[name] = [...Object.keys(dependencies), ...Object.keys(devDependencies)].sort(
+                (a, b) => a.localeCompare(b)
+            );
+            return result;
+        },
+        {}
     );
 }
 
-function withMetadata(packages: RawPackage[]): Package[] {
-    return packages.map(pkg => ({ ...pkg, type: getPackageType(pkg) }));
+function filterPackages(packages: ProjectPackage[], options: GetPackagesOptions) {
+    if (options.ignore === undefined && options.scope === undefined) {
+        return packages;
+    }
+
+    const patterns = [...toArray(options.scope), ...negate(toArray(options.ignore))];
+
+    if (patterns.length) {
+        if (!options.scope?.length) {
+            patterns.unshift('**');
+        }
+    }
+
+    const chosen = new Set(
+        multimatch(
+            packages.map(item => item.name),
+            patterns
+        )
+    );
+
+    return packages.filter(({ name }) => chosen.has(name));
+}
+
+function withMetadata(packages: ProjectPackage[]): Package[] {
+    return packages.map(pkg => {
+        const { name, version, location } = pkg;
+        return {
+            name,
+            version,
+            private: pkg.private ?? false,
+            location,
+            type: getPackageType(pkg),
+        };
+    });
 }
 
-function getPackageType({ location }: RawPackage) {
-    if (isLegacy(location)) {
+function getPackageType(packageJson: ProjectPackage) {
+    if (isLegacy(packageJson)) {
         return PackageType.Legacy;
     }
 
-    if (isBundle(location)) {
+    if (isBundle(packageJson)) {
         return PackageType.Webpack;
     }
 
@@ -129,3 +142,7 @@ export function splitPackagesByType(packages: Package[]) {
 
     return result;
 }
+
+function negate(patterns: string[]) {
+    return patterns.map(pattern => `!${pattern}`);
+}

package/dist/utils/maybe-create-git-folder.d.ts

@@ -1,10 +0,0 @@
-/**
- * Create empty .git folder to workaround issue where Lerna does not
- * detect workspace packages on Windows systems. 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 declare function maybeCreateGitFolder(): void;
-//# sourceMappingURL=maybe-create-git-folder.d.ts.map

package/dist/utils/maybe-create-git-folder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maybe-create-git-folder.d.ts","sourceRoot":"","sources":["../../src/utils/maybe-create-git-folder.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,SAOnC"}

package/dist/utils/maybe-create-git-folder.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeCreateGitFolder = void 0;
-const fs_1 = __importDefault(require("fs"));
-/**
- * Create empty .git folder to workaround issue where Lerna does not
- * detect workspace packages on Windows systems. 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)
- */
-function maybeCreateGitFolder() {
-    if (process.platform !== 'win32') {
-        return;
-    }
-    if (!fs_1.default.existsSync('.git')) {
-        fs_1.default.mkdirSync('.git');
-    }
-}
-exports.maybeCreateGitFolder = maybeCreateGitFolder;
-//# sourceMappingURL=maybe-create-git-folder.js.map

package/dist/utils/maybe-create-git-folder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"maybe-create-git-folder.js","sourceRoot":"","sources":["../../src/utils/maybe-create-git-folder.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AAEpB;;;;;;;GAOG;AACH,SAAgB,oBAAoB;IAChC,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;QAC/B,OAAO;IACX,CAAC;IACD,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACzB,YAAE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC;AACL,CAAC;AAPD,oDAOC"}

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

@@ -1,41 +0,0 @@
-import { fs, vol } from 'memfs';
-
-import { maybeCreateGitFolder } from '../maybe-create-git-folder';
-
-jest.mock('fs', () => fs);
-
-describe(`[startup] Utils`, () => {
-    describe(`${maybeCreateGitFolder.name}`, () => {
-        const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
-
-        beforeEach(() => vol.fromJSON({}));
-
-        afterEach(() => vol.reset);
-
-        const subject = () => maybeCreateGitFolder();
-
-        describe('when running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'win32' });
-            });
-
-            test('creates .git folder', () => {
-                subject();
-
-                expect(mkdirSpy).toHaveBeenCalledWith('.git');
-            });
-        });
-
-        describe('when not running on Windows', () => {
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-            });
-
-            test('does not create .git folder', () => {
-                subject();
-
-                expect(mkdirSpy).not.toHaveBeenCalledWith();
-            });
-        });
-    });
-});