@servicetitan/startup 24.1.0 → 24.1.2

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

@@ -1,8 +1,5 @@
-import execa from 'execa';
-import { isBundle, isLegacy } from '../get-configuration';
-import { log } from '../log';
-import { maybeCreateGitFolder } from '../maybe-create-git-folder';
-
+import path from 'path';
+import { fs, vol } from 'memfs';
 import {
     Package,
     PackageType,
@@ -11,178 +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());
 
-    function expectExecaToBeCalledWith(command: string, options?: execa.SyncOptions) {
-        const [file, ...args] = command.split(' ');
-        const { calls } = jest.mocked(execa.sync).mock;
-        const expected: any[] = [file, args, ...(options ? [options] : [])];
-        expect(calls).toContainEqual(expect.arrayContaining(expected));
-    }
-
     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);
-            expectExecaToBeCalledWith('npx lerna la --json');
+        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();
-
-            expect(maybeCreateGitFolder).toHaveBeenCalled();
-        });
+        describe('with "scope"', () => {
+            beforeEach(() => (options = { scope: 'foo' }));
 
-        describe('when running on Windows', () => {
-            const originalPlatform = process.platform;
-            beforeEach(() => {
-                Object.defineProperty(process, 'platform', { value: 'win32' });
+            test('returns only the specified packages', () => {
+                expect(subject()).toEqual([expect.objectContaining({ name: 'foo' })]);
             });
 
-            afterEach(() => {
-                Object.defineProperty(process, 'platform', { value: originalPlatform });
+            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('sets NX_CACHE_PROJECT_GRAPH=false', () => {
-                subject();
+            describe('when "scope" is a glob expression', () => {
+                beforeEach(() => (options = { scope: 'ba*' }));
 
-                expectExecaToBeCalledWith('npx lerna la --json', {
-                    extendEnv: true,
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    env: { NX_CACHE_PROJECT_GRAPH: 'false' },
+                test('returns only the specified packages', () => {
+                    expect(subject()).toEqual([
+                        expect.objectContaining({ name: 'bar' }),
+                        expect.objectContaining({ name: 'baz' }),
+                    ]);
                 });
             });
         });
 
-        describe.each(['scope', 'ignore'])('with "%s"', option => {
-            beforeEach(() => (options = { [option]: 'foo' }));
+        describe('with "ignore"', () => {
+            beforeEach(() => (options = { ignore: ['foo'] }));
+
+            test('omits the specified packages', () => {
+                expect(subject()).not.toContainEqual(expect.objectContaining({ name: 'foo' }));
+            });
 
-            test(`passes "${option}" option to lerna`, () => {
-                subject();
+            describe('when "ignore" is a glob expression', () => {
+                beforeEach(() => (options = { ignore: ['ba*'] }));
 
-                expectExecaToBeCalledWith(`npx lerna la --${option} foo --json`);
+                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' }));
+                });
             });
         });
 
-        describe('with "scope"', () => {
-            beforeEach(() => (options = { scope: 'foo' }));
-
-            test('returns filtered packages', () => {
-                expect(subject()).toEqual(packages.filter(({ name }) => name === 'foo'));
+        function itReturnsEmptyArray() {
+            test('returns empty array', () => {
+                expect(subject()).toEqual([]);
             });
+        }
 
-            describe('when filtered package has dependencies', () => {
-                beforeEach(() => (dependencies = { ...packageGraph(), foo: ['bar', 'external'] }));
+        describe('with no packages', () => {
+            beforeEach(() => vol.fromJSON({ 'package.json': JSON.stringify({}) }));
 
-                test('also returns internal dependencies', () => {
-                    expect(subject()).toEqual(
-                        packages.filter(({ name }) => ['foo', 'bar'].includes(name))
-                    );
-                });
-            });
+            itReturnsEmptyArray();
         });
 
-        describe('when execa returns unexpected output', () => {
-            beforeEach(() =>
-                jest.mocked(execa.sync).mockReturnValue({ stdout: Buffer.from('foo') } as any)
-            );
+        describe('with no package.json', () => {
+            beforeEach(() => vol.reset());
 
-            test('throws an error and logs the output', () => {
-                const logSpy = jest.spyOn(log, 'error');
-                expect(() => subject()).toThrow();
-                expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('\nfoo'));
-            });
+            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);
-            expectExecaToBeCalledWith('npx lerna la --graph');
+        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'] }));
 
-                expectExecaToBeCalledWith(`npx lerna la --${option} foo --graph`);
+            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,8 +1,7 @@
-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';
-import { log } from './log';
 
 export enum PackageType {
     TSC,
@@ -18,8 +17,6 @@ export interface Package {
     location: string;
 }
 
-type RawPackage = Omit<Package, 'type'>;
-
 interface GetPackagesOptions {
     scope?: string | string[];
     ignore?: string | string[];
@@ -29,16 +26,13 @@ export function getPackages(options: GetPackagesOptions = {}) {
     const scope = toArray(options.scope);
     const ignore = toArray(options.ignore);
 
-    maybeCreateGitFolder();
-    const allPackages: RawPackage[] = listPackages();
-
-    if (!scope.length && !ignore.length) {
+    const allPackages = findPackages();
+    if (scope.length === 0 && ignore.length === 0) {
         return withMetadata(allPackages);
     }
 
-    const filteredPackages: RawPackage[] = listPackages(options);
-
-    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)) {
@@ -68,63 +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[]> {
-    return listPackages({ ...options, graph: true });
+export function getPackagesGraph(options: GetPackagesOptions = {}) {
+    return buildPackageGraph(filterPackages(findPackages(), options));
 }
 
-function listPackages(options: GetPackagesOptions & { graph?: boolean } = {}) {
-    const scope = toArray(options.scope);
-    const ignore = toArray(options.ignore);
+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;
+        },
+        {}
+    );
+}
 
-    let execaOptions: execa.SyncOptions | undefined;
-    if (process.platform === 'win32') {
-        /*
-         * Disabled the project graph cache to workaround issue when nx fails with
-         * "Error: EPERM: operation not permitted, rename ..." error when multiple
-         * processes simultaneously generate the project graph.
-         */
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        execaOptions = { extendEnv: true, env: { NX_CACHE_PROJECT_GRAPH: 'false' } };
+function filterPackages(packages: ProjectPackage[], options: GetPackagesOptions) {
+    if (options.ignore === undefined && options.scope === undefined) {
+        return packages;
     }
 
-    const output = execa.sync(
-        'npx',
-        [
-            'lerna',
-            'la',
-            ...scope.map(v => ['--scope', v]).flat(),
-            ...ignore.map(v => ['--ignore', v]).flat(),
-            options.graph ? '--graph' : '--json',
-        ],
-        execaOptions
-    ).stdout;
-
-    try {
-        return JSON.parse(output);
-    } catch (error) {
-        log.error(`error: could not parse lerna output:\n${output}`);
-        throw error;
+    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: RawPackage[]): Package[] {
-    return packages.map(pkg => ({ ...pkg, type: getPackageType(pkg) }));
+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;
     }
 
@@ -144,3 +142,7 @@ export function splitPackagesByType(packages: Package[]) {
 
     return result;
 }
+
+function negate(patterns: string[]) {
+    return patterns.map(pattern => `!${pattern}`);
+}

package/template/lerna.json

@@ -1,5 +1,4 @@
 {
     "packages": ["packages/*"],
-    "version": "0.0.0",
-    "useWorkspaces": true
+    "version": "0.0.0"
 }

package/template/packages/application/package.json

@@ -8,11 +8,11 @@
     "scripts": {},
     "dependencies": {
         "@servicetitan/design-system": "^13.4.3",
-        "@servicetitan/hash-browser-router": "^23.1.0",
-        "@servicetitan/link-item": "^25.9.0",
-        "@servicetitan/log-service": "^23.1.0",
-        "@servicetitan/react-ioc": "^23.1.0",
-        "@servicetitan/web-components": "^23.1.0",
+        "@servicetitan/hash-browser-router": "^24.1.0",
+        "@servicetitan/link-item": "^26.1.0",
+        "@servicetitan/log-service": "^24.1.0",
+        "@servicetitan/react-ioc": "^24.1.0",
+        "@servicetitan/web-components": "^24.1.0",
         "axios": "^0.28.1",
         "feature-a": "^0.0.0",
         "feature-b": "^0.0.0",
@@ -24,7 +24,7 @@
         "react-router-dom": "^5.3.0"
     },
     "devDependencies": {
-        "@servicetitan/testing-library": "^0.3.0",
+        "@servicetitan/testing-library": "^1.2.0",
         "@testing-library/jest-dom": "^5.17.0",
         "@testing-library/react": "^12.1.5",
         "@testing-library/react-hooks": "^8.0.1",