@servicetitan/startup 36.3.0 → 36.4.0

package/src/core/create-build-context.ts

@@ -0,0 +1,61 @@
+import { getPackageManager } from '@servicetitan/install';
+import yargs, { Arguments } from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import {
+    getFolders,
+    getPackageData,
+    isExposeSharedDependencies,
+    isLegacyRoot,
+    isWebComponent,
+    loadSharedDependencies,
+} from '../utils';
+import { BuildContext, BuildIdentity } from './types';
+export type { BuildContext } from './types';
+
+export interface BuildContextOptions {
+    name: string;
+    isProduction: boolean;
+    light?: boolean;
+    headless?: boolean;
+    emitExposedDependencies?: BuildIdentity['emitExposedDependencies'];
+    outputBasePath?: string;
+    codeCoverage?: boolean;
+    buildStat?: boolean;
+}
+
+export function createBuildContext(options: BuildContextOptions): BuildContext {
+    const args = yargs(hideBin(process.argv)).argv as Arguments;
+    const { source, destination } = getFolders();
+    const packageData = getPackageData();
+    const sharedDependencies = loadSharedDependencies(
+        packageData.dependencies,
+        packageData.sharedDependencies
+    );
+
+    return {
+        package: {
+            name: packageData.name,
+            version: packageData.version,
+            destination,
+            source,
+            dependencies: packageData.dependencies,
+            sharedDependencies,
+            isWebComponent: isWebComponent(),
+            isLegacyRoot: isLegacyRoot(),
+            isExposeSharedDependencies: isExposeSharedDependencies(),
+            packageManager: getPackageManager(),
+        },
+        build: {
+            name: options.name,
+            isProduction: options.isProduction,
+            light: options.light,
+            headless: options.headless,
+            emitExposedDependencies: options.emitExposedDependencies,
+            outputBasePath: options.outputBasePath,
+        },
+        options: {
+            codeCoverage: options.codeCoverage ?? !!args['code-coverage'],
+            buildStat: options.buildStat,
+        },
+    };
+}

package/src/core/defines/define-exposed-dependencies.ts

@@ -0,0 +1,25 @@
+import { getExposedDependencies } from '../get-exposed-dependencies';
+import { BuildContext } from '../types';
+
+export function defineExposedDependencies(context: BuildContext) {
+    const { isExposeSharedDependencies, sharedDependencies, dependencies, packageManager } =
+        context.package;
+    const { emitExposedDependencies } = context.build;
+
+    if (!isExposeSharedDependencies || emitExposedDependencies) {
+        return;
+    }
+
+    const workspacePackage = packageManager.getWorkspacePackage();
+    const exposedDependencies = getExposedDependencies(
+        sharedDependencies,
+        dependency =>
+            packageManager.getResolvedVersion({ workspacePackage, dependency }) ??
+            dependencies?.[dependency]
+    );
+
+    return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        EXPOSED_DEPENDENCIES: JSON.stringify(exposedDependencies),
+    };
+}

package/src/core/defines/define-exposed-instance-dependencies.ts

@@ -0,0 +1,19 @@
+import { getLaunchDarklySdkVersion } from '../get-version';
+import { BuildContext } from '../types';
+
+export function defineExposedInstanceDependencies(context: BuildContext) {
+    const { isExposeSharedDependencies, packageManager } = context.package;
+    const { emitExposedDependencies } = context.build;
+    if (!isExposeSharedDependencies || emitExposedDependencies) {
+        return;
+    }
+
+    const instanceDependencies = {
+        launchDarkly: { version: getLaunchDarklySdkVersion(packageManager) },
+    };
+
+    return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        EXPOSED_INSTANCE_DEPENDENCIES: JSON.stringify(instanceDependencies),
+    };
+}

package/src/core/defines/define-web-component-name.ts

@@ -0,0 +1,15 @@
+import { BuildContext } from '../types';
+
+export function defineWebComponentName(context: BuildContext) {
+    const { isWebComponent } = context.package;
+    const { name } = context.build;
+
+    if (!isWebComponent) {
+        return;
+    }
+
+    return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        WEB_COMPONENT_NAME: JSON.stringify(name),
+    };
+}

package/src/core/defines/index.ts

@@ -0,0 +1,3 @@
+export { defineExposedDependencies } from './define-exposed-dependencies';
+export { defineExposedInstanceDependencies } from './define-exposed-instance-dependencies';
+export { defineWebComponentName } from './define-web-component-name';

package/src/core/externals.ts

@@ -0,0 +1,22 @@
+import { BuildContext } from './types';
+
+export function getExternals(context: BuildContext): Record<string, string> | undefined {
+    if (!needsExternals(context)) {
+        return;
+    }
+
+    const { sharedDependencies, isWebComponent } = context.package;
+    const name = isWebComponent ? context.build.name : context.package.name;
+    return Object.fromEntries(
+        Object.entries(sharedDependencies).map(([dependency, variable]) => [
+            dependency,
+            `${variable}['${name}']`,
+        ])
+    );
+}
+
+function needsExternals(context: BuildContext) {
+    const { light, emitExposedDependencies } = context.build;
+    const { isExposeSharedDependencies } = context.package;
+    return !!light || (isExposeSharedDependencies && !emitExposedDependencies);
+}

package/src/core/get-build-name.ts

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+import { getPackageName } from '../utils';
+
+export function getBuildName() {
+    const packageName = getPackageName()
+        .replace(/\//g, '-')
+        .replace(/[^\w-]/g, '');
+    const hash = crypto.randomBytes(4).toString('hex');
+
+    return `${packageName}-${hash}`;
+}

package/src/core/get-bundle-type.ts

@@ -0,0 +1,19 @@
+import { BuildContext } from './types';
+
+export function getBundleType(context: BuildContext) {
+    const { light, headless, emitExposedDependencies } = context.build;
+    const { isExposeSharedDependencies, isWebComponent } = context.package;
+
+    if (isExposeSharedDependencies && emitExposedDependencies) {
+        return 'shared';
+    }
+
+    if (isWebComponent) {
+        if (headless) {
+            return 'headless';
+        }
+        return light ? 'light' : 'full';
+    }
+
+    return undefined;
+}

package/src/core/get-cdn-path.ts

@@ -0,0 +1,5 @@
+import { BuildContext } from './types';
+
+export function getCdnPath(context: BuildContext) {
+    return context.build.isProduction ? process.env.CLIENT_CDN_PATH : undefined;
+}

package/src/core/get-output-path.ts

@@ -0,0 +1,15 @@
+import path from 'path';
+import { getBundleType } from './get-bundle-type';
+import { BuildContext } from './types';
+
+export function getOutputPath(context: BuildContext) {
+    const { destination } = context.package;
+    const { outputBasePath } = context.build;
+    const subdir = getBundleType(context) ?? '';
+
+    if (outputBasePath) {
+        return path.join(outputBasePath, subdir);
+    }
+
+    return path.join(process.cwd(), destination, 'bundle', subdir);
+}

package/src/core/get-shared-entry-points.ts

@@ -0,0 +1,37 @@
+import { readJsonSafe } from '../utils';
+import { getBundleType } from './get-bundle-type';
+import { getExposedDependenciesMetadataPath } from './metadata';
+import { BuildContext } from './types';
+
+export interface ExposedDepsMetadata {
+    entryPointsPath: string;
+}
+
+interface EntryPoints {
+    css: string[];
+    js: string[];
+}
+
+function getExposedDependenciesEntryPoints(context: BuildContext) {
+    const metadataPath = getExposedDependenciesMetadataPath(context.package.destination);
+    const metadata = readJsonSafe<ExposedDepsMetadata>(metadataPath);
+    if (metadata?.entryPointsPath) {
+        return readJsonSafe<EntryPoints>(metadata.entryPointsPath);
+    }
+}
+
+export function getSharedEntryPoints(context: BuildContext): EntryPoints {
+    const dirname = getBundleType({
+        ...context,
+        build: { ...context.build, emitExposedDependencies: true },
+    });
+    if (!dirname) {
+        return { css: [], js: [] };
+    }
+
+    const { css = [], js = [] } = getExposedDependenciesEntryPoints(context) ?? {};
+    return {
+        css: css.map(name => `${dirname}/${name}`),
+        js: js.map(name => `${dirname}/${name}`),
+    };
+}

package/src/core/get-version/__tests__/get-launchdarkly-sdk-version.test.ts

@@ -0,0 +1,48 @@
+import type { PackageManager } from '@servicetitan/install';
+import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
+
+describe(`[startup] ${getLaunchDarklySdkVersion.name}`, () => {
+    const launchDarklySdkVersion = '1.2.3';
+    const workspacePackage = 'packages/foo';
+    let getResolvedVersion: jest.Mock;
+    let packageManager: PackageManager;
+
+    beforeEach(() => {
+        getResolvedVersion = jest.fn();
+        packageManager = {
+            getResolvedVersion,
+            getWorkspacePackage: jest.fn().mockReturnValue(workspacePackage),
+        } as unknown as PackageManager;
+    });
+
+    const subject = () => getLaunchDarklySdkVersion(packageManager);
+
+    describe('when package is resolved', () => {
+        beforeEach(() => {
+            getResolvedVersion.mockReturnValue(launchDarklySdkVersion);
+        });
+
+        test('queries the launchdarkly sdk package version', () => {
+            subject();
+
+            expect(getResolvedVersion).toHaveBeenCalledWith({
+                workspacePackage,
+                dependency: 'launchdarkly-js-client-sdk',
+            });
+        });
+
+        test('returns version from package manager', () => {
+            expect(subject()).toEqual(launchDarklySdkVersion);
+        });
+    });
+
+    describe('when package is not resolved', () => {
+        beforeEach(() => {
+            getResolvedVersion.mockReturnValue(undefined);
+        });
+
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+    });
+});

package/src/core/get-version/__tests__/get-web-components-version.test.ts

@@ -0,0 +1,48 @@
+import type { PackageManager } from '@servicetitan/install';
+import { getWebComponentsVersion } from '../get-web-components-version';
+
+describe(`[startup] ${getWebComponentsVersion.name}`, () => {
+    const webComponentsVersion = '1.2.3';
+    const workspacePackage = 'packages/foo';
+    let getResolvedVersion: jest.Mock;
+    let packageManager: PackageManager;
+
+    beforeEach(() => {
+        getResolvedVersion = jest.fn();
+        packageManager = {
+            getResolvedVersion,
+            getWorkspacePackage: jest.fn().mockReturnValue(workspacePackage),
+        } as unknown as PackageManager;
+    });
+
+    const subject = () => getWebComponentsVersion(packageManager);
+
+    describe('when package is resolved', () => {
+        beforeEach(() => {
+            getResolvedVersion.mockReturnValue(webComponentsVersion);
+        });
+
+        test('queries the web-components package version', () => {
+            subject();
+
+            expect(getResolvedVersion).toHaveBeenCalledWith({
+                workspacePackage,
+                dependency: '@servicetitan/web-components',
+            });
+        });
+
+        test('returns version from package manager', () => {
+            expect(subject()).toEqual(webComponentsVersion);
+        });
+    });
+
+    describe('when package is not resolved', () => {
+        beforeEach(() => {
+            getResolvedVersion.mockReturnValue(undefined);
+        });
+
+        test('throws error', () => {
+            expect(subject).toThrow('Unable to resolve @servicetitan/web-components version');
+        });
+    });
+});

package/src/core/get-version/get-launchdarkly-sdk-version.ts

@@ -0,0 +1,8 @@
+import type { PackageManager } from '@servicetitan/install';
+
+export function getLaunchDarklySdkVersion(packageManager: PackageManager) {
+    return packageManager.getResolvedVersion({
+        workspacePackage: packageManager.getWorkspacePackage(),
+        dependency: 'launchdarkly-js-client-sdk',
+    });
+}

package/src/core/get-version/get-startup-version.ts

@@ -0,0 +1,6 @@
+import path from 'path';
+import { readJson } from '../../utils/read-json';
+
+export function getStartupVersion() {
+    return readJson(path.join(__dirname, '../../../package.json')).version;
+}

package/src/core/get-version/get-web-components-version.ts

@@ -0,0 +1,16 @@
+import type { PackageManager } from '@servicetitan/install';
+
+const PACKAGE_NAME = '@servicetitan/web-components';
+
+export function getWebComponentsVersion(packageManager: PackageManager) {
+    const version = packageManager.getResolvedVersion({
+        workspacePackage: packageManager.getWorkspacePackage(),
+        dependency: PACKAGE_NAME,
+    });
+
+    if (!version) {
+        throw new Error(`Unable to resolve ${PACKAGE_NAME} version`);
+    }
+
+    return version;
+}

package/src/core/get-version/index.ts

@@ -0,0 +1,3 @@
+export * from './get-launchdarkly-sdk-version';
+export * from './get-startup-version';
+export * from './get-web-components-version';

package/src/core/index.ts

@@ -0,0 +1,16 @@
+export * from './check-resource';
+export * from './constants';
+export * from './create-build-context';
+export * from './defines';
+export * from './externals';
+export * from './get-build-name';
+export * from './get-bundle-type';
+export * from './get-cdn-path';
+export * from './get-exposed-dependencies';
+export * from './get-output-path';
+export * from './get-shared-entry-points';
+export * from './get-version';
+export * from './metadata';
+export * from './stringify-config';
+export type * from './types';
+export * from './virtual-modules';

package/src/{webpack/configs/utils → core/metadata}/__tests__/build-metadata.test.ts

@@ -1,13 +1,17 @@
 import { fs, vol } from 'memfs';
-import { getStartupVersion } from '../../../../utils/get-startup-version';
+import {
+    getLaunchDarklySdkVersion,
+    getStartupVersion,
+    getWebComponentsVersion,
+} from '../../get-version';
 import { buildMetadata, BuildMetadataParams } from '../build-metadata';
-import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
-import { getWebComponentsVersion } from '../get-web-components-version';
 
 jest.mock('fs', () => fs);
-jest.mock('../../../../utils/get-startup-version');
-jest.mock('../get-launchdarkly-sdk-version');
-jest.mock('../get-web-components-version');
+jest.mock('../../get-version', () => ({
+    getLaunchDarklySdkVersion: jest.fn(),
+    getStartupVersion: jest.fn(),
+    getWebComponentsVersion: jest.fn(),
+}));
 
 describe(`[startup] ${buildMetadata.name}`, () => {
     const destination = 'dist';

package/src/{webpack/configs/utils → core/metadata}/__tests__/generate-metadata.test.ts

@@ -1,8 +1,8 @@
 import { fs, vol } from 'memfs';
 
 import * as mockedFs from 'fs';
-import { createPackage } from '../../../../__mocks__';
-import { Context } from '../../types';
+import { createPackage } from '../../../__mocks__';
+import { BuildContext } from '../../types';
 import { buildMetadata } from '../build-metadata';
 import { generateMetadata } from '../generate-metadata';
 
@@ -16,7 +16,7 @@ function generatedMetadata(dest: string) {
 describe(`[startup] ${generateMetadata.name}`, () => {
     const pkg = createPackage({});
     const destination = 'dist';
-    let context: Partial<Context>;
+    let context: BuildContext;
 
     const mockMetadata = {
         name: pkg.name,
@@ -36,16 +36,28 @@ describe(`[startup] ${generateMetadata.name}`, () => {
         jest.mocked(buildMetadata).mockReturnValue(mockMetadata);
 
         context = {
-            destination,
-            name: pkg.name,
-            packageData: { name: pkg.name, version: pkg.version, dependencies: { foo: '1.0.1' } },
-            sharedDependencies: { react: 'SharedDependencies.React' },
+            build: {
+                name: pkg.name,
+                isProduction: false,
+            },
+            package: {
+                name: pkg.name,
+                version: pkg.version,
+                destination,
+                source: 'src',
+                dependencies: { foo: '1.0.1' },
+                sharedDependencies: { react: 'SharedDependencies.React' },
+                isWebComponent: false,
+                isLegacyRoot: false,
+                isExposeSharedDependencies: false,
+            },
+            options: {},
         };
     });
 
     afterEach(() => vol.reset());
 
-    const subject = () => generateMetadata(context as any);
+    const subject = () => generateMetadata(context);
 
     function itWritesMetadataToDestination(destination: string) {
         test('writes metadata to output file', () => {
@@ -60,10 +72,10 @@ describe(`[startup] ${generateMetadata.name}`, () => {
 
         expect(buildMetadata).toHaveBeenCalledWith({
             destination,
-            name: context.name,
-            version: context.packageData!.version,
-            dependencies: context.packageData!.dependencies,
-            sharedDependencies: context.sharedDependencies,
+            name: context.build.name,
+            version: context.package.version,
+            dependencies: context.package.dependencies,
+            sharedDependencies: context.package.sharedDependencies,
         });
     });
 
@@ -72,7 +84,7 @@ describe(`[startup] ${generateMetadata.name}`, () => {
     describe('when destination directory does not exist', () => {
         const nestedDestination = 'nested/path/dist';
 
-        beforeEach(() => (context.destination = nestedDestination));
+        beforeEach(() => (context.package.destination = nestedDestination));
 
         test('creates destination directory', () => {
             subject();

package/src/{webpack/configs/utils → core/metadata}/build-metadata.ts

@@ -1,8 +1,12 @@
+import type { PackageManager } from '@servicetitan/install';
 import path from 'path';
-import { getStartupVersion, readJsonSafe } from '../../../utils';
+import { readJsonSafe } from '../../utils';
+import {
+    getLaunchDarklySdkVersion,
+    getStartupVersion,
+    getWebComponentsVersion,
+} from '../get-version';
 import { EntryPoints, Metadata } from '../types';
-import { getLaunchDarklySdkVersion } from './get-launchdarkly-sdk-version';
-import { getWebComponentsVersion } from './get-web-components-version';
 
 export interface BuildMetadataParams {
     destination: string;
@@ -10,10 +14,11 @@ export interface BuildMetadataParams {
     version: string;
     dependencies: Record<string, string>;
     sharedDependencies: Record<string, string>;
+    packageManager: PackageManager;
 }
 
 export function buildMetadata(params: BuildMetadataParams): Metadata {
-    const { destination, name, version, dependencies, sharedDependencies } = params;
+    const { destination, name, version, dependencies, sharedDependencies, packageManager } = params;
 
     const full = readJsonSafe(path.join(destination, 'bundle', 'full', 'entrypoints.json'));
     const light = readJsonSafe(path.join(destination, 'bundle', 'light', 'entrypoints.json'));
@@ -30,8 +35,8 @@ export function buildMetadata(params: BuildMetadataParams): Metadata {
         version,
         bundledWith: {
             '@servicetitan/startup': getStartupVersion(),
-            '@servicetitan/web-components': getWebComponentsVersion(),
-            'launchdarkly-js-client-sdk': getLaunchDarklySdkVersion(),
+            '@servicetitan/web-components': getWebComponentsVersion(packageManager),
+            'launchdarkly-js-client-sdk': getLaunchDarklySdkVersion(packageManager),
         },
         sharedDependencies,
         dependencies,

package/src/core/metadata/generate-exposed-dependencies-metadata.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+import { ExposedDepsMetadata } from '../get-shared-entry-points';
+
+export function getExposedDependenciesMetadataPath(destination: string) {
+    return path.join(destination, 'exposed-dependencies-metadata.json');
+}
+
+export function generateExposedDependenciesMetadata(
+    destination: string,
+    getOutputPath: () => string
+) {
+    if (!fs.existsSync(destination)) {
+        fs.mkdirSync(destination, { recursive: true });
+    }
+
+    const metadataPath = getExposedDependenciesMetadataPath(destination);
+    const metadata: ExposedDepsMetadata = { entryPointsPath: getOutputPath() };
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
+}

package/src/{webpack/configs/utils → core/metadata}/generate-metadata.ts

@@ -1,11 +1,13 @@
 import fs from 'fs';
 import path from 'path';
-import { log } from '../../../utils';
-import { Context } from '../types';
+import { log } from '../../utils';
+import { BuildContext } from '../types';
 import { buildMetadata } from './build-metadata';
 
-export function generateMetadata(context: Context) {
-    const { destination, name, packageData, sharedDependencies } = context;
+export function generateMetadata(context: BuildContext) {
+    const { destination, sharedDependencies, version, dependencies, packageManager } =
+        context.package;
+    const { name } = context.build;
 
     if (!fs.existsSync(destination)) {
         fs.mkdirSync(destination, { recursive: true });
@@ -14,9 +16,10 @@ export function generateMetadata(context: Context) {
     const metadata = buildMetadata({
         destination,
         name,
-        version: packageData.version,
-        dependencies: packageData.dependencies,
+        version,
+        dependencies,
         sharedDependencies,
+        packageManager,
     });
 
     const outputFile = path.join(destination, 'metadata.json');

package/src/core/metadata/index.ts

@@ -0,0 +1,3 @@
+export * from './build-metadata';
+export * from './generate-exposed-dependencies-metadata';
+export * from './generate-metadata';

package/src/core/types.ts

@@ -0,0 +1,54 @@
+import { getPackageManager } from '@servicetitan/install';
+
+export type BuildContext<T = unknown> = {
+    package: PackageContext;
+    build: BuildIdentity;
+    options: BuildOptions;
+} & (unknown extends T ? {} : { bundlerConfig: T });
+
+export interface PackageContext {
+    name: string;
+    version: string;
+    destination: string;
+    source: string;
+    dependencies: Record<string, string>;
+    sharedDependencies: Record<string, string>;
+    isWebComponent: boolean;
+    isLegacyRoot: boolean;
+    isExposeSharedDependencies: boolean;
+    packageManager: ReturnType<typeof getPackageManager>;
+}
+
+export interface BuildIdentity {
+    name: string;
+    isProduction: boolean;
+    light?: boolean;
+    headless?: boolean;
+    emitExposedDependencies?: boolean;
+    outputBasePath?: string;
+}
+
+export interface BuildOptions {
+    codeCoverage?: boolean;
+    buildStat?: boolean;
+}
+
+export interface EntryPoint {
+    css?: string[];
+    js?: string[];
+}
+
+export interface EntryPoints {
+    full?: EntryPoint;
+    light?: EntryPoint;
+    headless?: EntryPoint;
+}
+
+export interface Metadata {
+    name: string;
+    version: string;
+    bundledWith: Record<string, string | undefined>;
+    sharedDependencies: Record<string, string>;
+    dependencies: Record<string, string>;
+    entrypoints: EntryPoints;
+}