@servicetitan/startup 36.2.0 → 36.3.0-far-1776.3

package/src/cli/commands/mfe-check.ts

@@ -1,11 +1,13 @@
 import { getVersionMismatches } from '@servicetitan/startup-utils';
 import path from 'node:path';
 import {
+    getLockFileVersion,
     isWebComponent,
     loadSharedDependencies,
     log,
     logErrors,
     readJson,
+    readPackageLock,
     toArray,
 } from '../../utils';
 import { Metadata } from '../../webpack/configs/types';
@@ -82,9 +84,11 @@ export class MfeCheck extends Command<typeof entry> {
             hostData.dependencies,
             hostData.cli?.webpack?.['shared-dependencies']
         );
+        const lockFile = readPackageLock();
         const exposedDependencies = getExposedDependencies(
             hostSharedDependencies,
-            hostData.dependencies
+            dependency =>
+                getLockFileVersion(lockFile, dependency) ?? hostData.dependencies[dependency]
         );
         const mismatchResult = getVersionMismatches(
             exposedDependencies,

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

@@ -1,4 +1,4 @@
-import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
+import { getPackageData } from '../get-package-data';
 import { readJson } from '../read-json';
 
 jest.mock('../read-json', () => ({ readJson: jest.fn() }));
@@ -46,48 +46,4 @@ describe(`[startup] Utils`, () => {
             });
         });
     });
-
-    describe(`${getPackageDependencyVersion.name}`, () => {
-        const dependency = 'foo';
-        let defaultVersion: string | undefined;
-
-        beforeEach(() => (defaultVersion = undefined));
-
-        const subject = () => getPackageDependencyVersion(dependency, defaultVersion);
-
-        function itReturnsUndefinedOrDefaultVersion() {
-            test('returns undefined', () => {
-                expect(subject()).toBe(undefined);
-            });
-
-            describe('with a default version', () => {
-                beforeEach(() => (defaultVersion = '1.2.3'));
-
-                test('returns default version', () => {
-                    expect(subject()).toBe(defaultVersion);
-                });
-            });
-        }
-
-        itReturnsUndefinedOrDefaultVersion();
-
-        describe('when dependency exists', () => {
-            const module: Record<string, any> = {};
-
-            beforeEach(() => {
-                module.version = '2.3.4';
-                jest.doMock(`${dependency}/package.json`, () => module, { virtual: true });
-            });
-
-            test('returns dependency version', () => {
-                expect(subject()).toBe(module.version);
-            });
-
-            describe('when dependency has no version', () => {
-                beforeEach(() => delete module.version);
-
-                itReturnsUndefinedOrDefaultVersion();
-            });
-        });
-    });
 });

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

@@ -20,17 +20,3 @@ export function getPackageData(): PackageData {
         sharedDependencies: packageJson.cli?.webpack?.['shared-dependencies'],
     };
 }
-
-export function getPackageDependencyVersion(dependency: string, defaultVersion?: string) {
-    try {
-        const { version } = require(`${dependency}/package.json`);
-
-        if (version) {
-            return version;
-        }
-    } catch {
-        // skip error
-    }
-
-    return defaultVersion;
-}

package/src/utils/index.ts

@@ -19,6 +19,7 @@ export * from './load-shared-dependencies';
 export * from './log';
 export * from './log-errors';
 export * from './omit';
+export * from './package-lock';
 export * from './pick';
 export * from './prettify';
 export * from './read-json';

package/src/utils/package-lock/__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/package-lock/__tests__/get-lock-file-entry.test.ts

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

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

@@ -0,0 +1,32 @@
+import { getLockFileVersion } from '../get-lock-file-version';
+import type { PackageLock } from '../types';
+
+describe(`[startup] ${getLockFileVersion.name}`, () => {
+    const packageName = '@servicetitan/web-components';
+    const version = '1.2.3';
+    let lockFile: PackageLock;
+
+    beforeEach(() => {
+        lockFile = {
+            packages: {
+                [`node_modules/${packageName}`]: { version },
+            },
+        };
+    });
+
+    const subject = () => getLockFileVersion(lockFile, packageName);
+
+    test('returns version for a found package', () => {
+        expect(subject()).toBe(version);
+    });
+
+    describe('when entry has no version', () => {
+        beforeEach(() => {
+            delete lockFile.packages[`node_modules/${packageName}`].version;
+        });
+
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+    });
+});

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

@@ -0,0 +1,47 @@
+import { fs, vol } from 'memfs';
+import { readPackageLock } from '../read-package-lock';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] ${readPackageLock.name}`, () => {
+    const mockLockFile = {
+        packages: { 'node_modules/foo': { version: '1.2.3' } },
+    };
+
+    beforeEach(() => {
+        vol.fromJSON({ './package-lock.json': JSON.stringify(mockLockFile) });
+    });
+
+    afterEach(() => {
+        jest.resetModules();
+        vol.reset();
+    });
+
+    const subject = async () => {
+        const { readPackageLock } = await import('../read-package-lock');
+        return readPackageLock();
+    };
+
+    test('returns parsed lock file', async () => {
+        expect(await subject()).toEqual(mockLockFile);
+    });
+
+    describe('when called multiple times', () => {
+        test('reads file only once', async () => {
+            jest.spyOn(fs, 'readFileSync');
+
+            await subject();
+            await subject();
+
+            expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('when package-lock.json does not exist', () => {
+        beforeEach(() => fs.rmSync('package-lock.json'));
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow();
+        });
+    });
+});

package/src/utils/package-lock/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/package-lock/get-lock-file-entry.ts

@@ -0,0 +1,14 @@
+import type { PackageLock } from './types';
+
+export function getLockFileEntry(lockFile: PackageLock, packageName: string, scope?: string) {
+    const { packages } = lockFile;
+    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/utils/package-lock/get-lock-file-version.ts

@@ -0,0 +1,6 @@
+import { getLockFileEntry } from './get-lock-file-entry';
+import type { PackageLock } from './types';
+
+export function getLockFileVersion(lockFile: PackageLock, packageName: string) {
+    return getLockFileEntry(lockFile, packageName).version;
+}

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

@@ -0,0 +1,5 @@
+export * from './find-package-lock';
+export * from './get-lock-file-entry';
+export * from './get-lock-file-version';
+export * from './read-package-lock';
+export type { PackageLock, PackageLockPackages } from './types';

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

@@ -0,0 +1,13 @@
+import { readJson } from '../read-json';
+import { findPackageLock } from './find-package-lock';
+import type { PackageLock } from './types';
+
+let cachedLockFile: PackageLock | undefined;
+
+export function readPackageLock(): PackageLock {
+    if (!cachedLockFile) {
+        const lockFilePath = findPackageLock();
+        cachedLockFile = readJson<PackageLock>(lockFilePath!);
+    }
+    return cachedLockFile;
+}

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

@@ -0,0 +1,13 @@
+export interface PackageLockEntry {
+    version?: string;
+    resolved?: string;
+    link?: boolean;
+    dependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+}
+
+export type PackageLockPackages = Record<string, PackageLockEntry>;
+
+export interface PackageLock {
+    packages: PackageLockPackages;
+}

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -13,7 +13,6 @@ import yargs from 'yargs';
 import {
     getFolders,
     getPackageData,
-    getPackageDependencyVersion,
     getPackages,
     getTsConfig,
     isCustomStyleRules,
@@ -21,6 +20,7 @@ import {
     loadSharedDependencies,
     log,
     pick,
+    readPackageLock,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
 import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
@@ -46,7 +46,7 @@ jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     getFolders: jest.fn(),
     getPackageData: jest.fn(),
-    getPackageDependencyVersion: jest.fn(),
+    readPackageLock: jest.fn(),
     getPackages: jest.fn(),
     getTsConfig: jest.fn(),
     isCustomStyleRules: jest.fn(),
@@ -113,9 +113,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             dependencies,
             sharedDependencies,
         });
-        jest.mocked(getPackageDependencyVersion).mockImplementation(
-            (_, defaultVersion) => defaultVersion
-        );
+        jest.mocked(readPackageLock).mockReturnValue({ packages: {} });
         jest.mocked(getPackages).mockReturnValue([]);
         jest.mocked(getTsConfig).mockReturnValue(tsConfig);
         jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
@@ -162,7 +160,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 Object.entries(sharedDependencies).map(([name, variable]) => [
                     name,
                     {
-                        version: getPackageDependencyVersion(name, dependencies[name]),
+                        version: dependencies[name],
                         variable,
                     },
                 ])

package/src/webpack/__tests__/create-webpack-config.test.ts

@@ -17,7 +17,6 @@ import {
     getConfiguration,
     getFolders,
     getPackageData,
-    getPackageDependencyVersion,
     getPackages,
     getTsConfig,
     getWebpackConfiguration,
@@ -27,6 +26,7 @@ import {
     loadSharedDependencies,
     log,
     Package,
+    readPackageLock,
     WebpackConfiguration,
 } from '../../utils';
 import { fileRules, productionStyleRules, styleRules } from '../__mocks__';
@@ -60,7 +60,7 @@ jest.mock('../../utils', () => ({
     getConfiguration: jest.fn(),
     getFolders: jest.fn(),
     getPackageData: jest.fn(),
-    getPackageDependencyVersion: jest.fn(),
+    readPackageLock: jest.fn(),
     getPackages: jest.fn(),
     getTsConfig: jest.fn(),
     getWebpackConfiguration: jest.fn(),
@@ -146,9 +146,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             dependencies,
             sharedDependencies,
         });
-        jest.mocked(getPackageDependencyVersion).mockImplementation(
-            (_, defaultVersion) => defaultVersion
-        );
+        jest.mocked(readPackageLock).mockReturnValue({ packages: {} });
         jest.mocked(getPackages).mockImplementation(() => packages);
         jest.mocked(getTsConfig).mockReturnValue(tsConfig);
         jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);

package/src/webpack/configs/plugins/define-exposed-dependencies-plugin.ts

@@ -1,5 +1,5 @@
 import { DefinePlugin } from 'webpack';
-import { getPackageDependencyVersion } from '../../../utils';
+import { getLockFileVersion, readPackageLock } from '../../../utils';
 import { Context, Overrides } from '../types';
 import { getExposedDependencies } from '../utils';
 
@@ -10,8 +10,11 @@ export function defineExposedDependenciesPlugin(context: Context, _: Overrides)
     }
 
     const { packageData, sharedDependencies } = context;
-    const exposedDependencies = getExposedDependencies(sharedDependencies, dependency =>
-        getPackageDependencyVersion(dependency, packageData.dependencies?.[dependency])
+    const lockFile = readPackageLock();
+    const exposedDependencies = getExposedDependencies(
+        sharedDependencies,
+        dependency =>
+            getLockFileVersion(lockFile, dependency) ?? packageData.dependencies?.[dependency]
     );
 
     return new DefinePlugin({

package/src/webpack/configs/utils/__tests__/get-launchdarkly-sdk-version.test.ts

@@ -1,30 +1,47 @@
 import { fs, vol } from 'memfs';
-import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
 
 jest.mock('fs', () => fs);
 
-describe(`[startup] ${getLaunchDarklySdkVersion.name}`, () => {
+describe('[startup] getLaunchDarklySdkVersion', () => {
     const launchDarklySdkVersion = '1.2.3';
 
-    const subject = () => getLaunchDarklySdkVersion();
+    afterEach(() => {
+        jest.resetModules();
+        vol.reset();
+    });
+
+    const subject = async () => {
+        const { getLaunchDarklySdkVersion } = await import('../get-launchdarkly-sdk-version');
+        return getLaunchDarklySdkVersion();
+    };
 
-    test('returns undefined', () => {
-        expect(subject()).toBeUndefined();
+    describe('when package is not in package-lock.json', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({ packages: {} }),
+            });
+        });
+
+        test('returns undefined', async () => {
+            expect(await subject()).toBeUndefined();
+        });
     });
 
-    describe('when package is present', () => {
+    describe('when package is in package-lock.json', () => {
         beforeEach(() => {
             vol.fromJSON({
-                'node_modules/launchdarkly-js-client-sdk/package.json': JSON.stringify({
-                    version: launchDarklySdkVersion,
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/launchdarkly-js-client-sdk': {
+                            version: launchDarklySdkVersion,
+                        },
+                    },
                 }),
             });
         });
 
-        afterEach(() => vol.reset());
-
-        test('returns version from launchdarkly-js-client-sdk package', () => {
-            expect(subject()).toEqual(launchDarklySdkVersion);
+        test('returns version from package-lock.json', async () => {
+            expect(await subject()).toEqual(launchDarklySdkVersion);
         });
     });
 });

package/src/webpack/configs/utils/__tests__/get-web-components-version.test.ts

@@ -1,24 +1,49 @@
 import { fs, vol } from 'memfs';
-import { getWebComponentsVersion } from '../get-web-components-version';
 
 jest.mock('fs', () => fs);
 
-describe(`[startup] ${getWebComponentsVersion.name}`, () => {
+describe('[startup] getWebComponentsVersion', () => {
     const webComponentsVersion = '1.2.3';
 
-    beforeEach(() => {
-        vol.fromJSON({
-            'packages/web-components/package.json': JSON.stringify({
-                version: webComponentsVersion,
-            }),
-        });
+    afterEach(() => {
+        jest.resetModules();
+        vol.reset();
     });
 
-    afterEach(() => vol.reset());
+    const subject = async () => {
+        const { getWebComponentsVersion } = await import('../get-web-components-version');
+        return getWebComponentsVersion();
+    };
+
+    describe('when package is in package-lock.json', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/@servicetitan/web-components': {
+                            version: webComponentsVersion,
+                        },
+                    },
+                }),
+            });
+        });
+
+        test('returns version from package-lock.json', async () => {
+            expect(await subject()).toEqual(webComponentsVersion);
+        });
+    });
 
-    const subject = () => getWebComponentsVersion();
+    describe('when package is not in package-lock.json', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({ packages: {} }),
+            });
+        });
 
-    test('returns version from @servicetitan/web-components package', () => {
-        expect(subject()).toEqual(webComponentsVersion);
+        test('throws', async () => {
+            await expect(subject()).rejects.toThrow(
+                'Unable to resolve @servicetitan/web-components version from package-lock.json'
+            );
+        });
     });
 });

package/src/webpack/configs/utils/get-launchdarkly-sdk-version.ts

@@ -1,15 +1,5 @@
-import path from 'path';
-import { readJson } from '../../../utils';
+import { getLockFileVersion, readPackageLock } from '../../../utils';
 
 export function getLaunchDarklySdkVersion() {
-    try {
-        return readJson<{ version: string }>(
-            path.join(
-                path.dirname(require.resolve('launchdarkly-js-client-sdk')),
-                '../package.json'
-            )
-        ).version;
-    } catch {
-        // ignore
-    }
+    return getLockFileVersion(readPackageLock(), 'launchdarkly-js-client-sdk');
 }

package/src/webpack/configs/utils/get-web-components-version.ts

@@ -1,8 +1,11 @@
-import path from 'path';
-import { readJson } from '../../../utils';
+import { getLockFileVersion, readPackageLock } from '../../../utils';
 
 export function getWebComponentsVersion() {
-    return readJson<{ version: string }>(
-        path.join(path.dirname(require.resolve('@servicetitan/web-components')), '../package.json')
-    ).version;
+    const version = getLockFileVersion(readPackageLock(), '@servicetitan/web-components');
+    if (!version) {
+        throw new Error(
+            'Unable to resolve @servicetitan/web-components version from package-lock.json'
+        );
+    }
+    return version;
 }