@servicetitan/startup 35.1.0 → 35.2.0-far-1776.1

package/dist/webpack/configs/utils/get-web-components-version.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"sourcesContent":["import path from 'path';\nimport { readJson } from '../../../utils';\n\nexport function getWebComponentsVersion() {\n    return readJson<{ version: string }>(\n        path.join(path.dirname(require.resolve('@servicetitan/web-components')), '../package.json')\n    ).version;\n}\n"],"names":["getWebComponentsVersion","readJson","path","join","dirname","require","resolve","version"],"mappings":";;;;+BAGgBA;;;eAAAA;;;6DAHC;uBACQ;;;;;;AAElB,SAASA;IACZ,OAAOC,IAAAA,eAAQ,EACXC,aAAI,CAACC,IAAI,CAACD,aAAI,CAACE,OAAO,CAACC,QAAQC,OAAO,CAAC,kCAAkC,oBAC3EC,OAAO;AACb"}
+{"version":3,"sources":["../../../../src/webpack/configs/utils/get-web-components-version.ts"],"sourcesContent":["import { getPackageVersion } from '../../../utils';\n\nexport function getWebComponentsVersion() {\n    const version = getPackageVersion('@servicetitan/web-components');\n    if (!version) {\n        throw new Error(\n            'Unable to resolve @servicetitan/web-components version from package-lock.json'\n        );\n    }\n    return version;\n}\n"],"names":["getWebComponentsVersion","version","getPackageVersion","Error"],"mappings":";;;;+BAEgBA;;;eAAAA;;;uBAFkB;AAE3B,SAASA;IACZ,MAAMC,UAAUC,IAAAA,wBAAiB,EAAC;IAClC,IAAI,CAACD,SAAS;QACV,MAAM,IAAIE,MACN;IAER;IACA,OAAOF;AACX"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "35.1.0",
+    "version": "35.2.0-far-1776.1",
     "description": "CLI to create multi-package Lerna projects with TypeScript and React",
     "homepage": "https://docs.st.dev/docs/frontend/uikit/startup",
     "repository": {
@@ -145,6 +145,5 @@
     },
     "cli": {
         "webpack": false
-    },
-    "gitHead": "f1d49b43f27789cf5cd4bea3e065cd9e33bf5876"
+    }
 }

package/src/cli/commands/__tests__/mfe-generate-metadata.test.ts

@@ -35,6 +35,7 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
 
     const mockParentPackageJson = {
         name: 'parent-package',
+        workspaces: ['packages/*'],
         dependencies: { 'some-dep': '^1.0.0' },
     };
 
@@ -116,6 +117,18 @@ describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
         });
     });
 
+    describe('when tsconfig.json does not exist', () => {
+        beforeEach(() => {
+            fs.rmSync('tsconfig.json');
+        });
+
+        test('outputs metadata with empty entrypoints', async () => {
+            await subject();
+
+            expect(getMetadataFromStdout().entrypoints).toEqual({});
+        });
+    });
+
     describe('with --output option', () => {
         const outputDir = '/tmp/existing-dir';
         const outputPath = `${outputDir}/metadata.json`;

package/src/cli/commands/mfe-generate-metadata.ts

@@ -32,7 +32,12 @@ export class MfeGenerateMetadata extends Command<typeof options> {
 
         const { output } = this.args;
 
-        const { destination } = getFolders();
+        let destination: string;
+        try {
+            ({ destination } = getFolders());
+        } catch {
+            destination = 'dist';
+        }
         const name = getPackageName();
         const packageData = getPackageData();
         const sharedDependencies = loadSharedDependencies(

package/src/cli/commands/review/rules/require-compatible-launch-darkly-sdk.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { execSync } from 'child_process';
 import { satisfies } from 'semver';
+import { resolvePackageLockEntry } from '../../../../utils';
 import { FixCategory, Package, PackageError, PackageRule, Project } from '../types';
 import { applyFilter, checkPackages, setVersion } from '../utils';
 
@@ -121,13 +122,7 @@ export class RequireCompatibleLaunchDarklySdk implements PackageRule {
         dependency: string;
     }) {
         const { packages } = this.#project.packageLock;
-        return (
-            (packageName
-                ? packages[`node_modules/${packageName}/node_modules/${dependency}`]
-                : undefined) ??
-            packages[`node_modules/${dependency}`] ??
-            {}
-        );
+        return resolvePackageLockEntry(packages, dependency, packageName);
     }
 
     private getTargetJsClientSdkVersion(packageName?: string) {

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

@@ -1,3 +1,5 @@
+import { PackageLockPackages } from '../../../utils';
+
 export abstract class PackageRule {
     abstract get id(): string;
     abstract run(project: Project): PackageError | PackageError[] | undefined;
@@ -9,14 +11,7 @@ export interface Project {
     dependencies: Dependencies;
     // Only using this subset of package-lock.json
     packageLock: {
-        packages: Record<
-            string,
-            {
-                version: string;
-                dependencies?: Record<string, string>;
-                peerDependencies?: Record<string, string>;
-            }
-        >;
+        packages: PackageLockPackages;
         location: string;
     };
     packages: Package[];

package/src/utils/__tests__/find-package-lock.test.ts

@@ -0,0 +1,35 @@
+import { fs, vol } from 'memfs';
+import path from 'node:path';
+import { findPackageLock } from '../find-package-lock';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] ${findPackageLock.name}`, () => {
+    afterEach(() => vol.reset());
+
+    const subject = () => findPackageLock();
+
+    describe('when package-lock.json exists in cwd', () => {
+        beforeEach(() => {
+            vol.fromJSON({ './package-lock.json': '{}' });
+        });
+
+        test('returns path', () => {
+            expect(subject()).toBe(path.resolve('./package-lock.json'));
+        });
+    });
+
+    describe('when package-lock.json exists in parent directory', () => {
+        beforeEach(() => {
+            vol.fromJSON({ '../package-lock.json': '{}' });
+        });
+
+        test('returns path', () => {
+            expect(subject()).toBe(path.resolve('../package-lock.json'));
+        });
+    });
+
+    test('returns undefined when no package-lock.json exists', () => {
+        expect(subject()).toBeUndefined();
+    });
+});

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

@@ -1,47 +1,118 @@
+import { fs, vol } from 'memfs';
 import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
-import { readJson } from '../read-json';
 
-jest.mock('../read-json', () => ({ readJson: jest.fn() }));
+jest.mock('fs', () => fs);
 
 describe(`[startup] Utils`, () => {
     describe(`${getPackageData.name}`, () => {
-        const packageJson = './package.json';
-        const ancestorPackageJson = '../../package.json';
-        let packages: Record<string, Record<string, any>>;
-
-        beforeEach(() => {
-            packages = {
-                [ancestorPackageJson]: { dependencies: { foo: '1.0.0', bar: '2.0.0' } },
-                [packageJson]: {
+        afterEach(() => vol.reset());
+
+        const subject = () => getPackageData();
+
+        describe('when root package.json with workspaces exists', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        dependencies: { foo: '1.1.0', baz: '3.0.0' },
+                    }),
+                    '../package.json': JSON.stringify({
+                        workspaces: ['packages/*'],
+                        dependencies: { foo: '1.0.0', bar: '2.0.0' },
+                    }),
+                });
+            });
+
+            test('returns merged dependencies (local overrides root)', () => {
+                expect(subject()).toEqual({
                     name: 'packageName',
-                    dependencies: { foo: '1.1.0', baz: '3.0.0' },
-                },
-            };
-            jest.mocked(readJson).mockImplementation(path => packages[path] ?? {});
+                    dependencies: { foo: '1.1.0', bar: '2.0.0', baz: '3.0.0' },
+                });
+            });
         });
 
-        const subject = () => getPackageData();
+        describe('when no root package.json found', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'rootPackage',
+                        workspaces: ['packages/*'],
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                });
+            });
+
+            test('returns only local dependencies', () => {
+                expect(subject()).toEqual({
+                    name: 'rootPackage',
+                    dependencies: { foo: '1.0.0' },
+                });
+            });
+        });
+
+        describe('when root has lerna.json with packages instead of workspaces', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        version: '2.0.0',
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                    '../package.json': JSON.stringify({
+                        dependencies: { bar: '2.0.0' },
+                    }),
+                    '../lerna.json': JSON.stringify({
+                        packages: ['packages/*'],
+                    }),
+                });
+            });
+
+            test('returns dependencies from root discovered via lerna.json', () => {
+                expect(subject()).toEqual({
+                    name: 'packageName',
+                    version: '2.0.0',
+                    dependencies: { bar: '2.0.0', foo: '1.0.0' },
+                });
+            });
+        });
+
+        describe('when root has lerna.json but no package.json at root level', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        version: '3.0.0',
+                        dependencies: { foo: '1.0.0' },
+                    }),
+                    '../lerna.json': JSON.stringify({
+                        packages: ['packages/*'],
+                    }),
+                });
+            });
 
-        test(`returns merged dependencies from ${packageJson} and ${ancestorPackageJson}`, () => {
-            expect(subject()).toEqual({
-                name: packages[packageJson].name,
-                dependencies: {
-                    ...packages[ancestorPackageJson].dependencies,
-                    ...packages[packageJson].dependencies,
-                },
+            test('returns only local dependencies', () => {
+                expect(subject()).toEqual({
+                    name: 'packageName',
+                    version: '3.0.0',
+                    dependencies: { foo: '1.0.0' },
+                });
             });
         });
 
-        describe(`when ${packageJson} contains sharedDependencies`, () => {
+        describe('when package.json contains sharedDependencies', () => {
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
-                Object.assign(packages[packageJson], {
-                    cli: { webpack: { 'shared-dependencies': sharedDependencies } },
+                vol.fromJSON({
+                    './package.json': JSON.stringify({
+                        name: 'packageName',
+                        dependencies: { foo: '1.0.0' },
+                        cli: { webpack: { 'shared-dependencies': sharedDependencies } },
+                    }),
                 });
             });
 
-            test('returns sharedDependencies', () => {
+            test('result contains sharedDependencies', () => {
                 expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
             });
         });

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

@@ -0,0 +1,129 @@
+import { fs, vol } from 'memfs';
+import { getPackageVersion } from '../get-package-version';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] ${getPackageVersion.name}`, () => {
+    afterEach(() => vol.reset());
+
+    const subject = (packageName: string) => getPackageVersion(packageName);
+
+    beforeEach(() => {
+        vol.fromJSON({
+            './package-lock.json': JSON.stringify({
+                packages: {
+                    'node_modules/@servicetitan/web-components': { version: '1.2.3' },
+                },
+            }),
+        });
+    });
+
+    test('returns version for a found package', () => {
+        expect(subject('@servicetitan/web-components')).toBe('1.2.3');
+    });
+
+    describe('when package is not in lock file', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {},
+                }),
+            });
+        });
+
+        test('returns undefined', () => {
+            expect(subject('nonexistent-package')).toBeUndefined();
+        });
+    });
+
+    describe('when package is a linked workspace package', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/@servicetitan/web-components': {
+                            resolved: 'packages/web-components',
+                            link: true,
+                        },
+                        'packages/web-components': {
+                            version: '35.1.0',
+                        },
+                    },
+                }),
+            });
+        });
+
+        test('follows link to resolve version from source path', () => {
+            expect(subject('@servicetitan/web-components')).toBe('35.1.0');
+        });
+    });
+
+    describe('when entry has link but no resolved path', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/some-package': { link: true, version: '1.0.0' },
+                    },
+                }),
+            });
+        });
+
+        test('returns entry version', () => {
+            expect(subject('some-package')).toBe('1.0.0');
+        });
+    });
+
+    describe('when linked package resolved path does not exist in packages', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/some-package': {
+                            resolved: 'packages/some-package',
+                            link: true,
+                        },
+                    },
+                }),
+            });
+        });
+
+        test('returns undefined', () => {
+            expect(subject('some-package')).toBeUndefined();
+        });
+    });
+
+    describe('when lock file contains invalid JSON', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': 'not valid json',
+            });
+        });
+
+        test('returns undefined', () => {
+            expect(subject('some-package')).toBeUndefined();
+        });
+    });
+
+    describe('when lock file has no packages property', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({}),
+            });
+        });
+
+        test('returns undefined', () => {
+            expect(subject('some-package')).toBeUndefined();
+        });
+    });
+
+    describe('when package-lock.json does not exist', () => {
+        beforeEach(() => {
+            fs.rmSync('package-lock.json');
+        });
+
+        test('returns undefined', () => {
+            expect(subject('@servicetitan/web-components')).toBeUndefined();
+        });
+    });
+});

package/src/utils/__tests__/resolve-package-lock-entry.test.ts

@@ -0,0 +1,99 @@
+import { PackageLockPackages, resolvePackageLockEntry } from '../resolve-package-lock-entry';
+
+describe(`[startup] ${resolvePackageLockEntry.name}`, () => {
+    let packages: PackageLockPackages;
+    let packageName: string;
+    let scope: string | undefined;
+
+    beforeEach(() => {
+        packages = {};
+        packageName = 'foo';
+    });
+
+    const subject = () => resolvePackageLockEntry(packages, packageName, scope);
+
+    describe('when package exists at top level', () => {
+        beforeEach(() => {
+            packages['node_modules/foo'] = { version: '1.0.0' };
+        });
+
+        test('resolves the entry', () => {
+            expect(subject()).toEqual({ version: '1.0.0' });
+        });
+    });
+
+    describe('when package exists both at top level and under a scope', () => {
+        beforeEach(() => {
+            packages['node_modules/foo'] = { version: '1.0.0' };
+            packages['node_modules/parent/node_modules/foo'] = { version: '2.0.0' };
+            scope = undefined;
+        });
+
+        describe('when scope is provided', () => {
+            beforeEach(() => {
+                scope = 'parent';
+            });
+
+            test('resolves scoped entry', () => {
+                expect(subject()).toEqual({ version: '2.0.0' });
+            });
+        });
+
+        test('resolves top-level entry', () => {
+            expect(subject()).toEqual({ version: '1.0.0' });
+        });
+    });
+
+    describe('when package has dependencies and peerDependencies', () => {
+        beforeEach(() => {
+            packages['node_modules/foo'] = {
+                version: '1.0.0',
+                dependencies: { bar: '^1.0.0' },
+                peerDependencies: { baz: '>=2.0.0' },
+            };
+        });
+
+        test('returns the full entry', () => {
+            expect(subject()).toEqual({
+                version: '1.0.0',
+                dependencies: { bar: '^1.0.0' },
+                peerDependencies: { baz: '>=2.0.0' },
+            });
+        });
+    });
+
+    describe('when package is a linked workspace package', () => {
+        beforeEach(() => {
+            packages['node_modules/foo'] = { link: true, resolved: 'packages/foo' };
+            packages['packages/foo'] = { version: '3.0.0' };
+        });
+
+        test('follows link to resolved path', () => {
+            expect(subject()).toEqual({ version: '3.0.0' });
+        });
+
+        describe('when resolved entry does not exist', () => {
+            beforeEach(() => {
+                delete packages['packages/foo'];
+            });
+
+            test('returns empty object', () => {
+                expect(subject()).toEqual({});
+            });
+        });
+
+        describe('when resolved property is missing', () => {
+            beforeEach(() => {
+                delete packages['node_modules/foo'].resolved;
+            });
+
+            test('returns the entry as-is', () => {
+                expect(subject()).toEqual({ link: true });
+            });
+        });
+    });
+
+    test('returns empty object', () => {
+        expect(subject()).toEqual({});
+    });
+});

package/src/utils/find-package-lock.ts

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { findUp } from './find-up';
+
+export function findPackageLock() {
+    return findUp(directory => {
+        const lockFile = path.resolve(directory, 'package-lock.json');
+        return fs.existsSync(lockFile) ? lockFile : undefined;
+    });
+}

package/src/utils/find-up.ts

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 
 export function findUp<T>(callback: (directory: string) => T | undefined) {
     let directory = path.resolve('./');

package/src/utils/get-package-data.ts

@@ -1,4 +1,6 @@
-import { readJson } from './read-json';
+import path from 'node:path';
+import { findUp } from './find-up';
+import { readJson, readJsonSafe } from './read-json';
 
 interface PackageData {
     name: string;
@@ -14,13 +16,36 @@ export function getPackageData(): PackageData {
         name: packageJson.name,
         version: packageJson.version,
         dependencies: {
-            ...readJson('../../package.json').dependencies,
+            ...findRootDependencies(),
             ...packageJson.dependencies,
         },
         sharedDependencies: packageJson.cli?.webpack?.['shared-dependencies'],
     };
 }
 
+function findRootDependencies() {
+    const cwd = path.resolve('./');
+    const root = findUp(directory => {
+        if (directory === cwd) {
+            return undefined;
+        }
+        const pkgPath = path.join(directory, 'package.json');
+        const pkg = readJsonSafe<{ workspaces?: string[]; dependencies?: Record<string, string> }>(
+            pkgPath
+        );
+        if (pkg?.workspaces) {
+            return pkg;
+        }
+
+        const lernaPath = path.join(directory, 'lerna.json');
+        if (readJsonSafe<{ packages?: string[] }>(lernaPath)?.packages) {
+            return pkg ?? {};
+        }
+    });
+
+    return root?.dependencies ?? {};
+}
+
 export function getPackageDependencyVersion(dependency: string, defaultVersion?: string) {
     try {
         const { version } = require(`${dependency}/package.json`);

package/src/utils/get-package-version.ts

@@ -0,0 +1,21 @@
+import { findPackageLock } from './find-package-lock';
+import { readJsonSafe } from './read-json';
+import { PackageLockPackages, resolvePackageLockEntry } from './resolve-package-lock-entry';
+
+interface PackageLock {
+    packages: PackageLockPackages;
+}
+
+export function getPackageVersion(packageName: string) {
+    const lockFilePath = findPackageLock();
+    if (!lockFilePath) {
+        return undefined;
+    }
+
+    const lockFile = readJsonSafe<PackageLock>(lockFilePath);
+    if (!lockFile) {
+        return undefined;
+    }
+
+    return resolvePackageLockEntry(lockFile.packages, packageName).version;
+}

package/src/utils/index.ts

@@ -1,3 +1,4 @@
+export * from './find-package-lock';
 export * from './find-packages';
 export * from './find-up';
 export * from './format-duration';
@@ -10,6 +11,7 @@ export * from './get-folders';
 export * from './get-jest-config';
 export * from './get-package-data';
 export * from './get-package-name';
+export * from './get-package-version';
 export * from './get-packages';
 export * from './get-startup-version';
 export * from './get-tsconfig';
@@ -21,4 +23,5 @@ export * from './omit';
 export * from './pick';
 export * from './prettify';
 export * from './read-json';
+export * from './resolve-package-lock-entry';
 export * from './to-array';

package/src/utils/resolve-package-lock-entry.ts

@@ -0,0 +1,25 @@
+interface PackageLockEntry {
+    version?: string;
+    resolved?: string;
+    link?: boolean;
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+
+export type PackageLockPackages = Record<string, PackageLockEntry>;
+
+export function resolvePackageLockEntry(
+    packages: PackageLockPackages | undefined,
+    packageName: string,
+    scope?: string
+) {
+    const entry =
+        (scope ? packages?.[`node_modules/${scope}/node_modules/${packageName}`] : undefined) ??
+        packages?.[`node_modules/${packageName}`];
+
+    if (entry?.link && entry.resolved) {
+        return packages?.[entry.resolved] ?? {};
+    }
+
+    return entry ?? {};
+}

package/src/webpack/configs/cache-config.ts

@@ -1,7 +1,5 @@
-import fs from 'fs';
-import path from 'path';
 import { Configuration } from 'webpack';
-import { findUp } from '../../utils';
+import { findPackageLock } from '../../utils';
 import { Context, Overrides } from './types';
 
 type Config = Configuration['cache'];
@@ -28,10 +26,3 @@ export function cacheConfig(context: Context, _overrides: Overrides): Result {
         infrastructureLogging: { level: 'error' },
     };
 }
-
-function findPackageLock() {
-    return findUp(directory => {
-        const lockFile = path.resolve(path.join(directory), 'package-lock.json');
-        return fs.existsSync(lockFile) ? lockFile : undefined;
-    });
-}