@servicetitan/startup 33.1.1 → 34.0.0

package/src/webpack/configs/utils/__tests__/generate-metadata.test.ts

@@ -1,39 +1,39 @@
 import { fs, vol } from 'memfs';
+
 import * as mockedFs from 'fs';
 import { createPackage } from '../../../../__mocks__';
-import { getStartupVersion } from '../../../../utils/get-startup-version';
 import { Context } from '../../types';
-import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
-import { getWebComponentsVersion } from '../get-web-components-version';
-
+import { buildMetadata } from '../build-metadata';
 import { generateMetadata } from '../generate-metadata';
 
 jest.mock('fs', () => fs);
-jest.mock('../../../../utils/get-startup-version');
-jest.mock('../get-launchdarkly-sdk-version');
-jest.mock('../get-web-components-version');
+jest.mock('../build-metadata');
+
+function generatedMetadata(dest: string) {
+    return JSON.parse(mockedFs.readFileSync(`${dest}/metadata.json`, 'utf8'));
+}
 
 describe(`[startup] ${generateMetadata.name}`, () => {
     const pkg = createPackage({});
     const destination = 'dist';
-    const startupVersion = '1.0';
-    const webComponentsVersion = '2.0';
-    const launchDarklySdkVersion = '3.0';
     let context: Partial<Context>;
 
-    function generatedMetadata(destination: string) {
-        return JSON.parse(mockedFs.readFileSync(`${destination}/metadata.json`, 'utf8'));
-    }
-
-    function packageFS() {
-        return { 'package.json': JSON.stringify(pkg) };
-    }
+    const mockMetadata = {
+        name: pkg.name,
+        version: pkg.version,
+        bundledWith: {
+            '@servicetitan/startup': '1.0',
+            '@servicetitan/web-components': '2.0',
+            'launchdarkly-js-client-sdk': '3.0',
+        },
+        dependencies: { foo: '1.0.1' },
+        sharedDependencies: { react: '18.0.0' },
+        entrypoints: {},
+    };
 
     beforeEach(() => {
-        vol.fromJSON(packageFS());
-        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
-        jest.mocked(getWebComponentsVersion).mockReturnValue(webComponentsVersion);
-        jest.mocked(getLaunchDarklySdkVersion).mockReturnValue(launchDarklySdkVersion);
+        vol.fromJSON({});
+        jest.mocked(buildMetadata).mockReturnValue(mockMetadata);
 
         context = {
             destination,
@@ -47,43 +47,39 @@ describe(`[startup] ${generateMetadata.name}`, () => {
 
     const subject = () => generateMetadata(context as any);
 
-    test('generates package metadata', () => {
+    function itWritesMetadataToDestination(destination: string) {
+        test('writes metadata to output file', () => {
+            subject();
+
+            expect(generatedMetadata(destination)).toEqual(mockMetadata);
+        });
+    }
+
+    test('calls buildMetadata with correct parameters', () => {
         subject();
 
-        expect(generatedMetadata(destination)).toEqual({
+        expect(buildMetadata).toHaveBeenCalledWith({
+            destination,
             name: context.name,
             version: context.packageData!.version,
-            bundledWith: {
-                '@servicetitan/startup': startupVersion,
-                '@servicetitan/web-components': webComponentsVersion,
-                'launchdarkly-js-client-sdk': launchDarklySdkVersion,
-            },
             dependencies: context.packageData!.dependencies,
             sharedDependencies: context.sharedDependencies,
-            entrypoints: {},
         });
     });
 
-    describe('when package has entrypoints', () => {
-        const full = { css: 'foo', js: 'bar ' };
-        const light = { css: 'baz', js: 'qux' };
-        const headless = { css: 'quux', js: 'waldo' };
-
-        beforeEach(() => {
-            vol.fromJSON({
-                ...packageFS(),
-                [`${destination}/bundle/full/entrypoints.json`]: JSON.stringify(full),
-                [`${destination}/bundle/light/entrypoints.json`]: JSON.stringify(light),
-                [`${destination}/bundle/headless/entrypoints.json`]: JSON.stringify(headless),
-            });
-        });
+    itWritesMetadataToDestination(destination);
+
+    describe('when destination directory does not exist', () => {
+        const nestedDestination = 'nested/path/dist';
 
-        test('adds entrypoints to package metadata', () => {
+        beforeEach(() => (context.destination = nestedDestination));
+
+        test('creates destination directory', () => {
             subject();
 
-            expect(generatedMetadata(destination)).toEqual(
-                expect.objectContaining({ entrypoints: { full, light, headless } })
-            );
+            expect(mockedFs.existsSync(nestedDestination)).toBe(true);
         });
+
+        itWritesMetadataToDestination(nestedDestination);
     });
 });

package/src/webpack/configs/utils/__tests__/get-exposed-dependencies.test.ts

@@ -0,0 +1,39 @@
+import { getExposedDependencies } from '../get-exposed-dependencies';
+
+describe(`[startup] ${getExposedDependencies.name}`, () => {
+    let sharedDependencies: Record<string, string>;
+    let dependencies: Record<string, string>;
+    let callback: ((dependency: string) => string) | undefined;
+
+    beforeEach(() => {
+        sharedDependencies = {
+            foo: 'SharedDependencies.Foo',
+            bar: 'SharedDependencies.Bar',
+        };
+        dependencies = {
+            foo: '1.0.0',
+            bar: '2.0.0',
+        };
+        callback = undefined;
+    });
+
+    const subject = () => getExposedDependencies(sharedDependencies, callback ?? dependencies);
+
+    test('returns exposed dependencies', () => {
+        expect(subject()).toEqual({
+            foo: { version: '1.0.0', variable: 'SharedDependencies.Foo' },
+            bar: { version: '2.0.0', variable: 'SharedDependencies.Bar' },
+        });
+    });
+
+    describe('when passed a callback', () => {
+        beforeEach(() => (callback = name => `callback(${name})`));
+
+        test('uses version returned by callback', () => {
+            expect(subject()).toEqual({
+                foo: { version: 'callback(foo)', variable: 'SharedDependencies.Foo' },
+                bar: { version: 'callback(bar)', variable: 'SharedDependencies.Bar' },
+            });
+        });
+    });
+});

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

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { getWebComponentsVersion } from '../get-web-components-version';
 
 jest.mock('fs', () => fs);

package/src/webpack/configs/utils/build-metadata.ts

@@ -0,0 +1,40 @@
+import path from 'path';
+import { getStartupVersion, readJsonSafe } from '../../../utils';
+import { EntryPoints, Metadata } from '../types';
+import { getLaunchDarklySdkVersion } from './get-launchdarkly-sdk-version';
+import { getWebComponentsVersion } from './get-web-components-version';
+
+export interface BuildMetadataParams {
+    destination: string;
+    name: string;
+    version: string;
+    dependencies: Record<string, string>;
+    sharedDependencies: Record<string, string>;
+}
+
+export function buildMetadata(params: BuildMetadataParams): Metadata {
+    const { destination, name, version, dependencies, sharedDependencies } = params;
+
+    const full = readJsonSafe(path.join(destination, 'bundle', 'full', 'entrypoints.json'));
+    const light = readJsonSafe(path.join(destination, 'bundle', 'light', 'entrypoints.json'));
+    const headless = readJsonSafe(path.join(destination, 'bundle', 'headless', 'entrypoints.json'));
+
+    const entrypoints: EntryPoints = {
+        ...(full ? { full } : {}),
+        ...(light ? { light } : {}),
+        ...(headless ? { headless } : {}),
+    };
+
+    return {
+        name,
+        version,
+        bundledWith: {
+            '@servicetitan/startup': getStartupVersion(),
+            '@servicetitan/web-components': getWebComponentsVersion(),
+            'launchdarkly-js-client-sdk': getLaunchDarklySdkVersion(),
+        },
+        sharedDependencies,
+        dependencies,
+        entrypoints,
+    };
+}

package/src/webpack/configs/utils/generate-metadata.ts

@@ -1,10 +1,8 @@
 import fs from 'fs';
 import path from 'path';
-import { log, getStartupVersion, readJsonSafe } from '../../../utils';
-import { Context, Metadata } from '../types';
-
-import { getLaunchDarklySdkVersion } from './get-launchdarkly-sdk-version';
-import { getWebComponentsVersion } from './get-web-components-version';
+import { log } from '../../../utils';
+import { Context } from '../types';
+import { buildMetadata } from './build-metadata';
 
 export function generateMetadata(context: Context) {
     const { destination, name, packageData, sharedDependencies } = context;
@@ -13,25 +11,13 @@ export function generateMetadata(context: Context) {
         fs.mkdirSync(destination, { recursive: true });
     }
 
-    const full = readJsonSafe(path.join(destination, 'bundle', 'full', 'entrypoints.json'));
-    const light = readJsonSafe(path.join(destination, 'bundle', 'light', 'entrypoints.json'));
-    const headless = readJsonSafe(path.join(destination, 'bundle', 'headless', 'entrypoints.json'));
-    const metadata: Metadata = {
+    const metadata = buildMetadata({
+        destination,
         name,
         version: packageData.version,
-        bundledWith: {
-            '@servicetitan/startup': getStartupVersion(),
-            '@servicetitan/web-components': getWebComponentsVersion(),
-            'launchdarkly-js-client-sdk': getLaunchDarklySdkVersion(),
-        },
-        sharedDependencies,
         dependencies: packageData.dependencies,
-        entrypoints: {
-            ...(full ? { full } : {}),
-            ...(light ? { light } : {}),
-            ...(headless ? { headless } : {}),
-        },
-    };
+        sharedDependencies,
+    });
 
     const outputFile = path.join(destination, 'metadata.json');
     fs.writeFileSync(outputFile, JSON.stringify(metadata, null, 2), 'utf8');

package/src/webpack/configs/utils/get-exposed-dependencies.ts

@@ -0,0 +1,17 @@
+import type { ExposedDependencies } from '@servicetitan/startup-utils';
+
+export function getExposedDependencies(
+    sharedDependencies: Record<string, string>,
+    dependenciesOrCallback: Record<string, string> | ((dependency: string) => string)
+) {
+    const getVersion =
+        typeof dependenciesOrCallback === 'function'
+            ? dependenciesOrCallback
+            : (dependency: string) => dependenciesOrCallback[dependency];
+
+    return Object.entries(sharedDependencies).reduce<ExposedDependencies>(
+        (result, [dependency, variable]) =>
+            Object.assign(result, { [dependency]: { version: getVersion(dependency), variable } }),
+        {}
+    );
+}

package/src/webpack/configs/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './generate-metadata';
 export * from './get-bundle-type';
+export * from './get-exposed-dependencies';

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

@@ -1,7 +1,7 @@
 import { Configuration } from 'webpack';
 import { merge } from 'webpack-merge';
-import { argv, Arguments } from 'yargs';
-
+import yargs, { Arguments } from 'yargs';
+import { hideBin } from 'yargs/helpers';
 import { webpackDevConfigFileName, webpackProdConfigFileName } from '../cli/utils';
 import {
     getFolders,
@@ -79,7 +79,7 @@ function getContext({ configuration = {} }: Overrides, options: Options): Contex
         packageData.sharedDependencies
     );
 
-    const args = argv as Arguments;
+    const args = yargs(hideBin(process.argv)).argv as Arguments;
     const emitExposedDependencies = options.emitExposedDependencies;
 
     return {

package/src/webpack/loaders/expose-loader/__tests__/index.test.ts

@@ -3,9 +3,7 @@
  */
 
 import path from 'path';
-
 import { Stats } from 'webpack';
-
 import { getUtils } from '../../../utils/testing';
 
 const { compile, execute, getCompiler, getErrors, getModuleSource, getWarnings, readAsset } =

package/src/webpack/loaders/expose-loader/index.ts

@@ -1,5 +1,4 @@
 import { LoaderDefinitionFunction } from 'webpack';
-
 import { contextifyRequest, getNewUserRequest, stringifyRequest } from './utils';
 
 interface Options {

package/src/webpack/utils/testing/get-compiler.ts

@@ -1,10 +1,8 @@
+import { createFsFromVolume, Volume } from 'memfs';
 import path from 'path';
-
 import webpack, { Configuration } from 'webpack';
 import { merge } from 'webpack-merge';
 
-import { createFsFromVolume, Volume } from 'memfs';
-
 export function getCompilerFactory(cwd: string) {
     return function getCompiler(entry: string, loaderOptions = {}, config: Configuration = {}) {
         const compiler = webpack(

package/src/webpack/utils/testing/get-errors.ts

@@ -1,5 +1,4 @@
 import { Stats } from 'webpack';
-
 import { normalizeErrors } from './normalize-errors';
 
 export function getErrors(stats: Stats) {

package/src/webpack/utils/testing/get-warnings.ts

@@ -1,5 +1,4 @@
 import { Stats } from 'webpack';
-
 import { normalizeErrors } from './normalize-errors';
 
 export function getWarnings(stats: Stats) {

package/src/webpack/utils/testing/read-asset.ts

@@ -1,7 +1,6 @@
+import { IFs } from 'memfs';
 import path from 'path';
-
 import { Compiler, Stats } from 'webpack';
-import { IFs } from 'memfs';
 
 export function readAsset(asset: string, compiler: Compiler, stats: Stats) {
     const usedFs = compiler.outputFileSystem as IFs;

package/src/webpack/utils/testing/read-assets.ts

@@ -1,5 +1,4 @@
 import { Compiler, Stats } from 'webpack';
-
 import { readAsset } from './read-asset';
 
 export function readAssets(compiler: Compiler, stats: Stats) {