@servicetitan/startup 34.3.0-beta.2 → 35.0.0

package/src/cli/commands/__tests__/mfe-purge-cache.test.ts

@@ -0,0 +1,141 @@
+import { log } from '../../../utils';
+import { MFEPurgeCache, PurgeResponse } from '../mfe-purge-cache';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() },
+}));
+
+describe(`[startup] ${MFEPurgeCache.name}`, () => {
+    const host = 'https://unpkg.example.com';
+    const token = 'purge-token';
+    const tag = 'prod';
+    const packageName = '@servicetitan/foo';
+    const version = '0.0.0-master.abc1223';
+    const location = `/${packageName}@${version}/dist/metadata.json`;
+
+    let args: ConstructorParameters<typeof MFEPurgeCache>[0];
+    let fetchSpy: jest.SpyInstance;
+    let fetchResponse: any;
+    let responseJson: PurgeResponse;
+
+    beforeEach(() => {
+        process.env.UNPKG_PURGE_TOKEN = token;
+        args = { host, packageName, tag };
+        fetchResponse = {
+            ok: true,
+            json: jest.fn().mockImplementation(() => Promise.resolve(responseJson)),
+        };
+        responseJson = [{ pod: '10.36.110.200', status: 302, cache: 'BYPASS', location }];
+
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+        fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(() => fetchResponse);
+    });
+
+    afterEach(() => delete process.env.UNPKG_PURGE_TOKEN);
+
+    const subject = () => new MFEPurgeCache(args).execute();
+
+    test('sends POST request with X-Purge-Token header', async () => {
+        await subject();
+
+        expect(fetchSpy).toHaveBeenCalledWith(
+            `${host}/_purge/${packageName}@${tag}/dist/metadata.json`,
+            { method: 'POST', headers: { 'X-Purge-Token': token } }
+        );
+    });
+
+    test('logs progress', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(`Purging cache for ${packageName}@${tag}`);
+    });
+
+    test('logs the redirect location from the response', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(
+            `Cache purged: ${packageName}@${tag}/dist/metadata.json -> ${location.replace(/^\//, '')}`
+        );
+    });
+
+    describe('when request fails', () => {
+        beforeEach(() => {
+            fetchResponse = { ok: false, status: 403, statusText: 'Forbidden' };
+        });
+
+        test('throws error', () => {
+            expect(subject).rejects.toThrow(
+                `Purge request failed: ${fetchResponse.status} ${fetchResponse.statusText}`
+            );
+        });
+    });
+
+    function itLogsNullLocation() {
+        test('logs null location', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(expect.stringMatching(/-> null$/));
+        });
+    }
+
+    describe('when response location is null', () => {
+        beforeEach(() => (responseJson[0].location = null));
+
+        itLogsNullLocation();
+    });
+
+    describe('when response is empty', () => {
+        beforeEach(() => (responseJson = []));
+
+        itLogsNullLocation();
+    });
+
+    describe('when response is unexpected', () => {
+        beforeEach(() => (responseJson = {} as any));
+
+        itLogsNullLocation();
+    });
+
+    describe('when host has trailing slash', () => {
+        beforeEach(() => {
+            args.host = `${host}/`;
+        });
+
+        test('strips trailing slash from host', async () => {
+            await subject();
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                `${host}/_purge/${packageName}@${tag}/dist/metadata.json`,
+                expect.anything()
+            );
+        });
+    });
+
+    describe('with --token', () => {
+        const cliToken = 'cli-purge-token';
+
+        beforeEach(() => (args.token = cliToken));
+
+        test('uses specified token', async () => {
+            await subject();
+
+            expect(fetchSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.objectContaining({ headers: { 'X-Purge-Token': cliToken } })
+            );
+        });
+    });
+
+    describe('with no token', () => {
+        beforeEach(() => delete process.env.UNPKG_PURGE_TOKEN);
+
+        test('logs warning and does nothing', async () => {
+            await subject();
+
+            expect(log.warning).toHaveBeenCalledWith('Token is not defined, skipping purge');
+            expect(fetchSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/cli/commands/build.ts

@@ -8,11 +8,9 @@ const options = {
     codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
     config: { string: true, hidden: true, description: 'Use specified configuration' },
     ignore: { array: true, string: true, description: 'Packages to skip' },
-    preview: { boolean: true, description: 'Start preview server after build?' },
     scope: { array: true, string: true, description: 'Packages to build' },
     stat: { boolean: true, description: 'Generate bundle report?' },
     useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-    useVite: { boolean: true, description: 'Use Vite to bundle packages?' },
 } satisfies CommandOptions;
 
 enum BuildProcesses {
@@ -35,8 +33,6 @@ export class Build extends Command<typeof options> {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
         const useTsc = this.args.useTsc;
-        const useVite = this.args.useVite;
-        const cmd = useVite ? 'startup bundle-vite' : 'startup bundle-package';
 
         const packages = getPackages({
             scope: this.args.scope,
@@ -93,7 +89,7 @@ export class Build extends Command<typeof options> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': 'startup bundle-package',
                     'scope': webpackScope,
                     'parallel': true,
                     'stream': true,
@@ -116,14 +112,13 @@ export class Build extends Command<typeof options> {
                 }
 
                 return lernaExec({
-                    cmd,
+                    'cmd': 'startup bundle-package',
                     'scope': webpackScope,
                     'stream': true,
                     '--': [
                         ...[this.args.config ? `--config "${this.args.config}"` : undefined],
                         ...[this.args.codeCoverage ? '--code-coverage' : undefined],
                         ...[this.args.stat ? '--stat' : undefined],
-                        ...[useVite && this.args.preview ? '--preview' : undefined],
                     ].filter(item => !!item) as string[],
                 });
             },

package/src/cli/commands/bundle-package.ts

@@ -1,4 +1,4 @@
-import { getTsConfig, log, logErrors, validateSharedDependenciesConsistency } from '../../utils';
+import { getTsConfig, log, logErrors } from '../../utils';
 import { bundle, getModuleType } from '../utils';
 import { Command, CommandOptions } from './types';
 
@@ -15,8 +15,6 @@ export class BundlePackage extends Command<typeof options> {
     static readonly options = options;
     @logErrors
     async execute() {
-        validateSharedDependenciesConsistency();
-
         const {
             config,
             codeCoverage,

package/src/cli/commands/get-command.ts

@@ -1,7 +1,6 @@
 import { CommandName } from '../../utils';
 import { Build } from './build';
 import { BundlePackage } from './bundle-package';
-import { BundleVite } from './bundle-vite';
 import { Clean } from './clean';
 import { ConvertEslintConfig } from './convert-eslint-config';
 import { ESLintCommand } from './eslint';
@@ -16,6 +15,7 @@ import { MFEPackageClean } from './mfe-package-clean';
 import { MFEPackagePublish } from './mfe-package-publish';
 import { MFEPackageRollback } from './mfe-package-rollback';
 import { MFEPublish } from './mfe-publish';
+import { MFEPurgeCache } from './mfe-purge-cache';
 import { PreparePackage } from './prepare-package';
 import { Review } from './review';
 import { RunTask } from './run-task';
@@ -29,7 +29,6 @@ import { UploadSourcemaps } from './upload-sourcemaps';
 const commands: Record<CommandName, Newable<Command>> = {
     [CommandName.build]: Build,
     [CommandName['bundle-package']]: BundlePackage,
-    [CommandName['bundle-vite']]: BundleVite,
     [CommandName['convert-eslint-config']]: ConvertEslintConfig,
     [CommandName.clean]: Clean,
     [CommandName.eslint]: ESLintCommand,
@@ -44,6 +43,7 @@ const commands: Record<CommandName, Newable<Command>> = {
     [CommandName['mfe-package-publish']]: MFEPackagePublish,
     [CommandName['mfe-package-rollback']]: MFEPackageRollback,
     [CommandName['mfe-publish']]: MFEPublish,
+    [CommandName['mfe-purge-cache']]: MFEPurgeCache,
     [CommandName['prepare-package']]: PreparePackage,
     [CommandName.review]: Review,
     [CommandName.start]: Start,

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

@@ -1,6 +1,5 @@
 import { getVersionMismatches } from '@servicetitan/startup-utils';
 import path from 'node:path';
-import { getExposedDependencies, Metadata } from '../../core';
 import {
     isWebComponent,
     loadSharedDependencies,
@@ -9,6 +8,8 @@ import {
     readJson,
     toArray,
 } from '../../utils';
+import { Metadata } from '../../webpack/configs/types';
+import { getExposedDependencies } from '../../webpack/configs/utils';
 import { Command, CommandOptions } from './types';
 
 interface HostPackageJSON {

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

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { buildMetadata } from '../../core';
 import {
     getFolders,
     getPackageData,
@@ -10,6 +9,7 @@ import {
     log,
     logErrors,
 } from '../../utils';
+import { buildMetadata } from '../../webpack/configs/utils/build-metadata';
 import { Command, CommandOptions } from './types';
 
 const options = {

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

@@ -1,6 +1,5 @@
 import fs from 'fs';
 import path from 'path';
-import { EntryPoint, EntryPoints, Metadata } from '../../core';
 import {
     getBranchesConfigs,
     getFolders,
@@ -9,6 +8,7 @@ import {
     logErrors,
     readJson,
 } from '../../utils';
+import { EntryPoint, EntryPoints, Metadata } from '../../webpack/configs';
 import {
     DRY_RUN_PREFIX,
     getDefaultBuildVersion,
@@ -22,7 +22,7 @@ import {
     runCommand,
 } from '../utils';
 import { Command, CommandOptions } from './types';
-import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
 
 export const mfePackagePublishOptions = {
     branch: {
@@ -59,6 +59,11 @@ export const mfePackagePublishOptions = {
         description: 'Upload source maps to Datadog?',
         defaultDescription: 'true',
     },
+    purgeCache: {
+        boolean: true,
+        description: 'Purge unpkg cache after publishing?',
+        defaultDescription: 'true',
+    },
 } satisfies CommandOptions;
 
 interface PublishData {
@@ -100,6 +105,11 @@ export class MFEPackagePublish extends Command<typeof mfePackagePublishOptions>
 
         await this.maybePublishPackage(packageJson, data);
 
+        const { dry, tag } = data;
+        if (this.args.purgeCache !== false && !dry) {
+            purgeCache({ packageName: packageJson.name, tag });
+        }
+
         if (data.uploadSourcemaps) {
             this.uploadSourcemaps(data);
         }

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

@@ -1,7 +1,7 @@
 import { log, logErrors, readJson } from '../../utils';
 import { DRY_RUN_PREFIX, npmTagVersion, npmView } from '../utils';
 import { Command, CommandOptions } from './types';
-import { buildRollbackTag, DEFAULT_MFE_REGISTRY } from './utils';
+import { DEFAULT_MFE_REGISTRY, buildRollbackTag, purgeCache } from './utils';
 
 export const mfePackageRollbackOptions = {
     dry: {
@@ -18,6 +18,11 @@ export const mfePackageRollbackOptions = {
         description: 'The tag to rollback to its previous version',
         required: true,
     },
+    purgeCache: {
+        boolean: true,
+        description: 'Purge unpkg cache after rolling back?',
+        defaultDescription: 'true',
+    },
 } satisfies CommandOptions;
 
 interface PackageJson {
@@ -25,8 +30,6 @@ interface PackageJson {
 }
 
 export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions> {
-    static readonly description = 'Rollback a package to a previous tagged version';
-
     static readonly options = mfePackageRollbackOptions;
 
     private get dryRunPrefix() {
@@ -35,11 +38,16 @@ export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions
 
     @logErrors
     async execute() {
-        if (this.args.dry) {
+        const { dry, tag } = this.args;
+        if (dry) {
             log.warning('DRY-RUN MODE ENABLED, WILL NOT PERFORM ROLLBACK');
         }
 
-        await this.handleRollback();
+        const packageName = await this.handleRollback();
+
+        if (packageName && this.args.purgeCache !== false && !dry) {
+            purgeCache({ packageName, tag });
+        }
     }
 
     private async handleRollback() {
@@ -96,5 +104,7 @@ export class MFEPackageRollback extends Command<typeof mfePackageRollbackOptions
                 tag,
             });
         }
+
+        return packageName;
     }
 }

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

@@ -111,17 +111,28 @@ export class MFEPublish extends Command<MFEPublishOptions> {
     }
 
     getPublishOptions() {
-        const { build, branch, dry, force, registry, tag, uploadSourcemaps, trackHistory } =
-            this.args;
+        const {
+            build,
+            branch,
+            dry,
+            force,
+            purgeCache,
+            registry,
+            tag,
+            uploadSourcemaps,
+            trackHistory,
+        } = this.args;
         return [
             ...[branch && `--branch ${branch}`],
             ...[build && `--build ${build}`],
             ...[dry && '--dry'],
             ...[force && '--force'],
+            ...[purgeCache === true && '--purge-cache'],
+            ...[purgeCache === false && '--no-purge-cache'],
             ...[registry && `--registry ${registry}`],
+            ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[trackHistory === true && '--track-history'],
             ...[trackHistory === false && '--no-track-history'],
-            ...[typeof tag === 'string' && `--tag ${tag}`],
             ...[uploadSourcemaps === true && `--upload-sourcemaps`],
             ...[uploadSourcemaps === false && `--no-upload-sourcemaps`],
         ].filter(item => !!item) as string[];

package/src/cli/commands/mfe-purge-cache.ts

@@ -0,0 +1,75 @@
+import { log, logErrors } from '../../utils';
+import { Command, CommandOptions } from './types';
+
+const mfePurgeCacheOptions = {
+    host: {
+        string: true,
+        description: 'Host URL to send purge requests to',
+        demandOption: true,
+    },
+    packageName: {
+        string: true,
+        description: 'Package name to purge',
+        demandOption: true,
+    },
+    tag: {
+        string: true,
+        description: 'Package tag to purge',
+        demandOption: true,
+    },
+    token: {
+        string: true,
+        description: 'X-Purge-Token header value',
+        defaultDescription: 'process.env.UNPKG_PURGE_TOKEN',
+    },
+} satisfies CommandOptions;
+
+export type PurgeResponse = {
+    pod: string;
+    status: number;
+    cache: string | null;
+    location: string | null;
+}[];
+
+export class MFEPurgeCache extends Command<typeof mfePurgeCacheOptions> {
+    static readonly options = mfePurgeCacheOptions;
+
+    @logErrors
+    async execute() {
+        const { host: rawHost, packageName, tag } = this.args;
+        const host = rawHost.replace(/\/$/, '');
+        const token = this.args.token ?? process.env.UNPKG_PURGE_TOKEN;
+        const packageNameAndTag = `${packageName}@${tag}`;
+        const path = `${packageNameAndTag}/dist/metadata.json`;
+
+        log.info(`Purging cache for ${packageNameAndTag}`);
+
+        if (!token) {
+            log.warning('Token is not defined, skipping purge');
+            return;
+        }
+
+        const response = await fetch(`${host}/_purge/${path}`, {
+            method: 'POST',
+            headers: { 'X-Purge-Token': token },
+        });
+
+        if (!response.ok) {
+            throw new Error(`Purge request failed: ${response.status} ${response.statusText}`);
+        }
+
+        const responseJson = await response.json();
+        /* istanbul ignore next: debug only */
+        log.debug('mfe-purge-cache', () => JSON.stringify(responseJson, null, 2));
+
+        log.info(`Cache purged: ${path} -> ${this.getLocation(responseJson)}`);
+    }
+
+    private getLocation(responseJson: PurgeResponse) {
+        let location: string | null = null;
+        if (Array.isArray(responseJson)) {
+            location = responseJson[0]?.location?.replace(/^\//, '') ?? null;
+        }
+        return location;
+    }
+}

package/src/cli/commands/start.ts

@@ -16,7 +16,6 @@ const options = {
     ignore: { array: true, string: true, description: 'Packages to skip' },
     scope: { array: true, string: true, description: 'Packages to run and watch' },
     useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-    useVite: { boolean: true, description: 'Use Vite to bundle packages?' },
 } satisfies CommandOptions;
 
 enum StartProcesses {
@@ -40,8 +39,6 @@ export class Start extends Command<typeof options> {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
         const useTsc = this.args.useTsc;
-        const useVite = this.args.useVite;
-        const cmd = useVite ? 'startup bundle-vite' : 'startup bundle-package';
 
         const packages = getPackages({
             scope: this.args.scope,
@@ -154,7 +151,7 @@ export class Start extends Command<typeof options> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': 'startup bundle-package',
                     'scope': webpackScope,
                     'parallel': true,
                     'stream': true,
@@ -170,7 +167,7 @@ export class Start extends Command<typeof options> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': 'startup bundle-package',
                     'scope': webpackScope,
                     'parallel': true,
                     'stream': true,

package/src/cli/commands/utils/__tests__/purge-cache.test.ts

@@ -0,0 +1,40 @@
+import { runCommandOutput } from '../../../utils';
+import { purgeCache } from '../purge-cache';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    runCommandOutput: jest.fn(),
+}));
+
+describe(purgeCache.name, () => {
+    let args: Parameters<typeof purgeCache>[0];
+    const packageName = '@servicetitan/foo';
+    const tag = 'prod';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = { packageName, tag };
+    });
+
+    const subject = () => purgeCache(args);
+
+    test('runs mfe-purge-cache with host "https://unpkg.servicetitan.com", package name and tag', () => {
+        subject();
+
+        expect(runCommandOutput).toHaveBeenCalledWith(
+            `npx startup mfe-purge-cache --host https://unpkg.servicetitan.com --package-name ${packageName} --tag ${tag}`
+        );
+    });
+
+    describe('when registry is "https://verdaccio.st.dev"', () => {
+        beforeEach(() => (args.registry = 'https://verdaccio.st.dev'));
+
+        test('runs mfe-purge-cache with host "https://unpkg.st.dev"', () => {
+            subject();
+
+            expect(runCommandOutput).toHaveBeenCalledWith(
+                expect.stringContaining(`--host https://unpkg.st.dev`)
+            );
+        });
+    });
+});

package/src/cli/commands/{utils.ts → utils/build-rollback-tag.ts}

@@ -1,4 +1,3 @@
-export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';
 export const ROLLBACK_TAG_SUFFIX = '-rollback-1';
 
 export function buildRollbackTag(tag: string): string {

package/src/cli/commands/utils/constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_MFE_REGISTRY = 'https://verdaccio.servicetitan.com';

package/src/cli/commands/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './build-rollback-tag';
+export * from './constants';
+export * from './purge-cache';

package/src/cli/commands/utils/purge-cache.ts

@@ -0,0 +1,13 @@
+import { runCommandOutput } from '../../utils';
+
+const DEV_MFE_REGISTRY = 'https://verdaccio.st.dev';
+const DEFAULT_UNPKG_HOST = 'https://unpkg.servicetitan.com';
+const DEV_UNPKG_HOST = 'https://unpkg.st.dev';
+
+export function purgeCache(options: { packageName: string; registry?: string; tag: string }) {
+    const { packageName, registry, tag } = options;
+    const host = registry === DEV_MFE_REGISTRY ? DEV_UNPKG_HOST : DEFAULT_UNPKG_HOST;
+    runCommandOutput(
+        `npx startup mfe-purge-cache --host ${host} --package-name ${packageName} --tag ${tag}`
+    );
+}

package/src/cli/utils/__tests__/bundle.test.ts

@@ -12,12 +12,8 @@ import {
     isExposeSharedDependencies,
     loadSharedDependencies,
 } from '../../../utils';
-import { createWebpackConfig, createWebpackConfigs } from '../../../webpack';
-import {
-    webpackDevConfigFileName,
-    webpackProdConfigFileName,
-} from '../../../webpack/create-webpack-config';
-import { bundle } from '../bundle';
+import { createWebpackConfig } from '../../../webpack';
+import { bundle, webpackDevConfigFileName, webpackProdConfigFileName } from '../bundle';
 
 jest.mock('fs', () => fs);
 jest.mock('portfinder');
@@ -28,16 +24,11 @@ jest.mock('../../../utils', () => ({
     getFolders: jest.fn(),
     getPackageData: jest.fn(),
     hasHeadlessBundle: jest.fn(),
-    isDevServerDisabled: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
-    isWebComponent: jest.fn(),
     loadSharedDependencies: jest.fn(),
     log: { info: jest.fn(), debug: jest.fn() }, // suppress test output
 }));
-jest.mock('../../../webpack', () => ({
-    createWebpackConfig: jest.fn(),
-    createWebpackConfigs: jest.fn(),
-}));
+jest.mock('../../../webpack', () => ({ createWebpackConfig: jest.fn() }));
 
 describe('[startup] Cli Utils', () => {
     const pkg = createPackage({});
@@ -46,7 +37,7 @@ describe('[startup] Cli Utils', () => {
 
     beforeEach(() => {
         jest.resetAllMocks();
-        jest.mocked(createWebpackConfigs).mockReturnValue([createWebpackResult]);
+        jest.mocked(createWebpackConfig).mockReturnValue(createWebpackResult);
         jest.mocked(webpack).mockImplementation((): any => compiler);
         jest.mocked(getPortPromise).mockImplementation(options =>
             Promise.resolve(options?.port ?? 0)
@@ -302,7 +293,7 @@ describe('[startup] Cli Utils', () => {
                 };
             });
 
-            test('builds full and light packages', async () => {
+            test('builds full and "embed" packages', async () => {
                 await subject();
 
                 expect(createWebpackConfig).toHaveBeenCalledWith(
@@ -311,7 +302,7 @@ describe('[startup] Cli Utils', () => {
                 );
                 expect(createWebpackConfig).toHaveBeenCalledWith(defaultCreateOverrides, {
                     ...defaultCreateOptions,
-                    light: true,
+                    embed: true,
                 });
                 expect(compiler.run).toHaveBeenCalledTimes(2);
             });
@@ -348,7 +339,7 @@ describe('[startup] Cli Utils', () => {
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, createOptions);
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
                         ...createOptions,
-                        light: true,
+                        embed: true,
                     });
                 });
             }
@@ -535,7 +526,7 @@ describe('[startup] Cli Utils', () => {
                 expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
                 expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
                     ...options,
-                    light: true,
+                    embed: true,
                 });
                 expect(webpack).toHaveBeenNthCalledWith(1, createWebpackResult);
                 expect(webpack).toHaveBeenNthCalledWith(2, createWebpackResult);
@@ -577,7 +568,7 @@ describe('[startup] Cli Utils', () => {
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
                         ...options,
-                        light: true,
+                        embed: true,
                     });
                     expect(WebpackDevServer).not.toHaveBeenCalled();
                 });
@@ -597,7 +588,7 @@ describe('[startup] Cli Utils', () => {
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
                     expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
                         ...options,
-                        light: true,
+                        embed: true,
                     });
                 });
             }