@servicetitan/startup 35.0.0 → 35.2.0-far-1776.0

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

@@ -0,0 +1,120 @@
+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);
+
+    describe('when package-lock.json exists', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({
+                    packages: {
+                        'node_modules/@servicetitan/web-components': { version: '1.2.3' },
+                        'node_modules/launchdarkly-js-client-sdk': { version: '4.5.6' },
+                    },
+                }),
+            });
+        });
+
+        test('returns version for a found package', () => {
+            expect(subject('@servicetitan/web-components')).toBe('1.2.3');
+        });
+
+        test('returns version for another found package', () => {
+            expect(subject('launchdarkly-js-client-sdk')).toBe('4.5.6');
+        });
+
+        test('returns undefined for a package not in lock file', () => {
+            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();
+        });
+    });
+
+    test('returns undefined when no package-lock.json exists', () => {
+        expect(subject('@servicetitan/web-components')).toBeUndefined();
+    });
+});

package/src/utils/__tests__/get-tsconfig-with-fallback.test.ts

@@ -0,0 +1,23 @@
+import { fs, vol } from 'memfs';
+import { getBaseTsConfig } from '../get-base-tsconfig';
+import { getTsConfigWithFallback } from '../get-tsconfig-with-fallback';
+
+jest.mock('fs', () => fs);
+
+describe(`[startup] Utils`, () => {
+    describe(`${getTsConfigWithFallback.name}`, () => {
+        afterEach(() => vol.reset());
+
+        test('returns base.json', () => {
+            expect(getTsConfigWithFallback()).toBe(getBaseTsConfig());
+        });
+
+        describe('when tsconfig exists', () => {
+            beforeEach(() => vol.fromJSON({ 'tsconfig.json': JSON.stringify({}) }));
+
+            test('returns tsconfig', () => {
+                expect(getTsConfigWithFallback()).toBe('tsconfig.json');
+            });
+        });
+    });
+});

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

@@ -1,5 +1,5 @@
 import { fs, vol } from 'memfs';
-import path from 'path';
+import path from 'node:path';
 import { getTsConfig } from '../get-tsconfig';
 
 jest.mock('fs', () => fs);
@@ -36,9 +36,9 @@ describe(`[startup] Utils`, () => {
             });
 
             describe(`when ${buildConfig} is present`, () => {
-                beforeEach(() => {
-                    vol.fromJSON({ [`packages/foo/${buildConfig}`]: JSON.stringify({}) });
-                });
+                beforeEach(() =>
+                    vol.fromJSON({ [`packages/foo/${buildConfig}`]: JSON.stringify({}) })
+                );
 
                 test(`returns {location}/${buildConfig}`, () => {
                     expect(subject()).toBe(path.join(location!, buildConfig));

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-base-tsconfig.ts

@@ -0,0 +1,5 @@
+import path from 'node:path';
+
+export function getBaseTsConfig() {
+    return path.resolve(__dirname, '../../tsconfig/base.json');
+}

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,31 @@
+import { findPackageLock } from './find-package-lock';
+import { readJsonSafe } from './read-json';
+
+interface PackageLockEntry {
+    version?: string;
+    resolved?: string;
+    link?: boolean;
+}
+
+interface PackageLock {
+    packages: Record<string, PackageLockEntry>;
+}
+
+export function getPackageVersion(packageName: string) {
+    const lockFilePath = findPackageLock();
+    if (!lockFilePath) {
+        return undefined;
+    }
+
+    const lockFile = readJsonSafe<PackageLock>(lockFilePath);
+    const entry = lockFile?.packages?.[`node_modules/${packageName}`];
+    if (!entry) {
+        return undefined;
+    }
+
+    if (entry.link && entry.resolved) {
+        return lockFile?.packages?.[entry.resolved]?.version;
+    }
+
+    return entry.version;
+}

package/src/utils/get-tsconfig-with-fallback.ts

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import { getBaseTsConfig } from './get-base-tsconfig';
+import { getTsConfig } from './get-tsconfig';
+
+/**
+ * Returns the tsconfig file to use for builds, falling back to startup's base.json
+ * if no tsconfig is found at the given location.
+ */
+export function getTsConfigWithFallback(location = './') {
+    const config = getTsConfig(location);
+    return fs.existsSync(config) ? config : getBaseTsConfig();
+}

package/src/utils/index.ts

@@ -1,7 +1,9 @@
+export * from './find-package-lock';
 export * from './find-packages';
 export * from './find-up';
 export * from './format-duration';
 export * from './format-relative-date';
+export * from './get-base-tsconfig';
 export * from './get-branch-configs';
 export * from './get-configuration';
 export * from './get-destination-folders';
@@ -9,9 +11,11 @@ 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';
+export * from './get-tsconfig-with-fallback';
 export * from './load-shared-dependencies';
 export * from './log';
 export * from './log-errors';

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;
-    });
-}

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

@@ -6,25 +6,41 @@ jest.mock('fs', () => fs);
 describe(`[startup] ${getLaunchDarklySdkVersion.name}`, () => {
     const launchDarklySdkVersion = '1.2.3';
 
+    afterEach(() => vol.reset());
+
     const subject = () => 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', () => {
+            expect(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', () => {
+        test('returns version from package-lock.json', () => {
             expect(subject()).toEqual(launchDarklySdkVersion);
         });
     });
+
+    test('returns undefined when no package-lock.json exists', () => {
+        expect(subject()).toBeUndefined();
+    });
 });

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

@@ -6,19 +6,39 @@ jest.mock('fs', () => fs);
 describe(`[startup] ${getWebComponentsVersion.name}`, () => {
     const webComponentsVersion = '1.2.3';
 
-    beforeEach(() => {
-        vol.fromJSON({
-            'packages/web-components/package.json': JSON.stringify({
-                version: webComponentsVersion,
-            }),
-        });
-    });
-
     afterEach(() => vol.reset());
 
     const subject = () => getWebComponentsVersion();
 
-    test('returns version from @servicetitan/web-components package', () => {
-        expect(subject()).toEqual(webComponentsVersion);
+    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', () => {
+            expect(subject()).toEqual(webComponentsVersion);
+        });
+    });
+
+    describe('when package is not in package-lock.json', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package-lock.json': JSON.stringify({ packages: {} }),
+            });
+        });
+
+        test('throws', () => {
+            expect(subject).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 { getPackageVersion } 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 getPackageVersion('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 { getPackageVersion } from '../../../utils';
 
 export function getWebComponentsVersion() {
-    return readJson<{ version: string }>(
-        path.join(path.dirname(require.resolve('@servicetitan/web-components')), '../package.json')
-    ).version;
+    const version = getPackageVersion('@servicetitan/web-components');
+    if (!version) {
+        throw new Error(
+            'Unable to resolve @servicetitan/web-components version from package-lock.json'
+        );
+    }
+    return version;
 }