@servicetitan/startup 36.3.1 → 37.0.0

package/src/vite/config/__tests__/create-vite-build-context.test.ts

@@ -0,0 +1,89 @@
+import { type BuildContext } from '../../../core';
+import type { VitePackageJsonOverride } from '../../../utils/get-configuration';
+import { createViteBuildContext } from '../create-vite-build-context';
+import type { ViteConfigFileOverride } from '../define-config';
+
+describe(createViteBuildContext.name, () => {
+    const context = {
+        build: { name: 'test' },
+        package: { destination: 'dist' },
+    } as BuildContext;
+
+    let pkgJsonConfig: VitePackageJsonOverride;
+    let fileConfig: ViteConfigFileOverride;
+
+    beforeEach(() => {
+        pkgJsonConfig = {};
+        fileConfig = {};
+    });
+
+    const subject = () => createViteBuildContext(context, pkgJsonConfig, fileConfig);
+
+    test('includes context properties', () => {
+        expect(subject()).toEqual(expect.objectContaining(context));
+    });
+
+    test('defaults bundlerConfig to empty values', () => {
+        expect(subject().bundlerConfig).toEqual({
+            port: undefined,
+            omitDefault: [],
+            pluginOverrides: { html: {}, svgr: {} },
+            minify: {},
+        });
+    });
+
+    describe('when port is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { port: 3000 };
+            fileConfig = { port: 9000 };
+        });
+
+        test('file config takes precedence', () => {
+            expect(subject().bundlerConfig.port).toBe(fileConfig.port);
+        });
+    });
+
+    describe('when omitDefault is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { omitDefault: ['plugin-a'] };
+            fileConfig = { omitDefault: ['plugin-b'] };
+        });
+
+        test('concatenates entries from both sources', () => {
+            expect(subject().bundlerConfig.omitDefault).toEqual(['plugin-a', 'plugin-b']);
+        });
+    });
+
+    describe('when pluginOverrides is provided', () => {
+        const pkgHtml = { title: 'pkg', favicon: 'pkg.ico' };
+        const fileHtml = { title: 'file' };
+        const pkgSvgr = { include: ['**/*.svg'], exclude: ['**/ignore/**'] };
+        const fileSvgr = { include: ['**/*.icon.svg'] };
+
+        beforeEach(() => {
+            pkgJsonConfig = { pluginOverrides: { html: pkgHtml, svgr: pkgSvgr } };
+            fileConfig = { pluginOverrides: { html: fileHtml, svgr: fileSvgr } };
+        });
+
+        test('merges with file config taking precedence', () => {
+            const { pluginOverrides } = subject().bundlerConfig;
+
+            expect(pluginOverrides.html).toEqual({ ...pkgHtml, ...fileHtml });
+            expect(pluginOverrides.svgr).toEqual({ ...pkgSvgr, ...fileSvgr });
+        });
+    });
+
+    describe('when minify is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { minify: { css: true, js: false } };
+            fileConfig = { minify: { js: true } };
+        });
+
+        test('merges with file config taking precedence', () => {
+            expect(subject().bundlerConfig.minify).toEqual({
+                ...pkgJsonConfig.minify,
+                ...fileConfig.minify,
+            });
+        });
+    });
+});

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

@@ -0,0 +1,219 @@
+import { createBuildContext, resolveOutputPath, resolveOutputRoot } from '../../../core';
+import { getViteConfiguration } from '../../../utils';
+import { createBaseConfig } from '../base-config';
+import { createViteBuildContext } from '../create-vite-build-context';
+import { createViteConfig } from '../create-vite-config';
+import { getWarmupClientFiles } from '../get-warmup-client-files';
+import { loadConfigFile } from '../load-config-file';
+import { mergeViteConfigs } from '../merge-vite-configs';
+
+jest.mock('../../../core', () => ({
+    ...jest.requireActual('../../../core'),
+    createBuildContext: jest.fn(),
+}));
+jest.mock('../../../utils', () => ({
+    getViteConfiguration: jest.fn(),
+    log: { debug: jest.fn() },
+}));
+jest.mock('../base-config', () => ({
+    createBaseConfig: jest.fn(),
+}));
+jest.mock('../create-vite-build-context', () => ({
+    createViteBuildContext: jest.fn(),
+}));
+jest.mock('../load-config-file', () => ({
+    loadConfigFile: jest.fn(),
+}));
+jest.mock('../merge-vite-configs', () => ({
+    mergeViteConfigs: jest.fn(),
+}));
+jest.mock('../get-warmup-client-files', () => ({
+    getWarmupClientFiles: jest.fn(),
+}));
+
+describe(createViteConfig.name, () => {
+    const options = { name: 'test', isProduction: false };
+    const warmupFiles = ['dist/**/*.js', '!dist/bundle/**'];
+    const mockBaseConfig: any = { root: '/' };
+    const mockFinalConfig: any = { server: { port: 3000 } };
+
+    let mockContext: any;
+    let mockPackageJsonConfig: any;
+    let mockFileConfig: any;
+    let mockViteBuildContext: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockContext = { build: {}, package: { destination: 'dist' } };
+        mockPackageJsonConfig = { omitDefault: ['from-pkg'] };
+        mockFileConfig = { omitDefault: ['from-file'] };
+        mockViteBuildContext = { ...mockContext, bundlerConfig: {} };
+
+        jest.mocked(createBuildContext).mockReturnValue(mockContext);
+        jest.mocked(getViteConfiguration).mockReturnValue(mockPackageJsonConfig);
+        jest.mocked(loadConfigFile).mockResolvedValue(mockFileConfig);
+        jest.mocked(createViteBuildContext).mockReturnValue(mockViteBuildContext);
+        jest.mocked(createBaseConfig).mockReturnValue(mockBaseConfig);
+        jest.mocked(mergeViteConfigs).mockReturnValue({ ...mockFinalConfig });
+        jest.mocked(getWarmupClientFiles).mockReturnValue(warmupFiles);
+    });
+
+    const subject = () => createViteConfig(options);
+
+    const itSetsPortToZero = () => {
+        test('sets port to 0', async () => {
+            expect((await subject()).server?.port).toBe(0);
+        });
+    };
+
+    test('builds context from options', async () => {
+        await subject();
+
+        expect(createBuildContext).toHaveBeenCalledWith(options);
+    });
+
+    test('loads config file with context', async () => {
+        await subject();
+
+        expect(loadConfigFile).toHaveBeenCalledWith('./', mockContext);
+    });
+
+    test('creates vite context from all config sources', async () => {
+        await subject();
+
+        expect(createViteBuildContext).toHaveBeenCalledWith(
+            expect.objectContaining(mockContext),
+            mockPackageJsonConfig,
+            mockFileConfig
+        );
+    });
+
+    test('creates base config from vite context', async () => {
+        await subject();
+
+        expect(createBaseConfig).toHaveBeenCalledWith(mockViteBuildContext);
+    });
+
+    test('merges base, package.json, and file configs', async () => {
+        await subject();
+
+        expect(mergeViteConfigs).toHaveBeenCalledWith(
+            mockBaseConfig,
+            mockPackageJsonConfig,
+            mockFileConfig
+        );
+    });
+
+    test('returns merged config', async () => {
+        expect(await subject()).toEqual(
+            expect.objectContaining({
+                server: expect.objectContaining(mockFinalConfig.server),
+            })
+        );
+    });
+
+    test('resolves build.outDir from the configured outDir', async () => {
+        expect((await subject()).build?.outDir).toBe(resolveOutputPath(mockContext, undefined));
+    });
+
+    test('sets warmup.clientFiles for the dev server', async () => {
+        expect((await subject()).server?.warmup?.clientFiles).toBe(warmupFiles);
+    });
+
+    test('warms the resolved output root', async () => {
+        await subject();
+
+        expect(getWarmupClientFiles).toHaveBeenCalledWith(
+            mockViteBuildContext,
+            resolveOutputRoot(mockContext, undefined)
+        );
+    });
+
+    describe('when consumer config sets warmup', () => {
+        beforeEach(() =>
+            jest.mocked(mergeViteConfigs).mockReturnValue({
+                server: { warmup: { clientFiles: ['custom/**'], ssrFiles: ['ssr/**'] } },
+            })
+        );
+
+        test('consumer clientFiles take precedence', async () => {
+            expect((await subject()).server?.warmup?.clientFiles).toEqual(['custom/**']);
+        });
+
+        test('preserves other consumer warmup options', async () => {
+            expect((await subject()).server?.warmup?.ssrFiles).toEqual(['ssr/**']);
+        });
+    });
+
+    describe('when the merged config sets a custom outDir', () => {
+        const outDir = '/custom';
+
+        beforeEach(() =>
+            jest.mocked(mergeViteConfigs).mockReturnValue({ ...mockFinalConfig, build: { outDir } })
+        );
+
+        test('resolves build.outDir from the custom outDir', async () => {
+            expect((await subject()).build?.outDir).toBe(resolveOutputPath(mockContext, outDir));
+        });
+
+        test('warms the custom output root', async () => {
+            await subject();
+
+            expect(getWarmupClientFiles).toHaveBeenCalledWith(
+                mockViteBuildContext,
+                resolveOutputRoot(mockContext, outDir)
+            );
+        });
+    });
+
+    describe('when production', () => {
+        beforeEach(() => (mockContext.build.isProduction = true));
+
+        test('skips warmup', async () => {
+            expect((await subject()).server?.warmup).toBeUndefined();
+        });
+    });
+
+    describe('when build is light', () => {
+        beforeEach(() => (mockContext.build.light = true));
+
+        itSetsPortToZero();
+    });
+
+    describe('when build is headless', () => {
+        beforeEach(() => (mockContext.build.headless = true));
+
+        itSetsPortToZero();
+    });
+
+    describe('when PORT env is set', () => {
+        beforeEach(() => {
+            process.env.PORT = '8080';
+            jest.mocked(mergeViteConfigs).mockReturnValue({});
+        });
+
+        afterEach(() => {
+            delete process.env.PORT;
+        });
+
+        test('uses PORT env value', async () => {
+            expect((await subject()).server?.port).toBe(8080);
+        });
+    });
+
+    describe('when build emits exposed dependencies', () => {
+        beforeEach(() => {
+            process.env.PORT = '9999';
+            mockContext.build.emitExposedDependencies = true;
+        });
+
+        afterEach(() => {
+            delete process.env.PORT;
+        });
+
+        test('does not override port', async () => {
+            expect((await subject()).server?.port).toBe(mockFinalConfig.server.port);
+        });
+    });
+});

package/src/vite/config/__tests__/define-config.test.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from '../define-config';
+
+describe('[startup] defineConfig', () => {
+    let config: Parameters<typeof defineConfig>[0];
+
+    const subject = () => defineConfig(config);
+
+    describe('with an object config', () => {
+        beforeEach(() => (config = { config: { build: { minify: false } } }));
+
+        test('returns the config as-is', () => {
+            expect(subject()).toBe(config);
+        });
+    });
+
+    describe('with a function config', () => {
+        beforeEach(() => (config = () => ({ config: { build: { minify: false } } })));
+
+        test('returns the function as-is', () => {
+            expect(subject()).toBe(config);
+        });
+    });
+});

package/src/vite/config/__tests__/get-warmup-client-files.test.ts

@@ -0,0 +1,20 @@
+import path from 'path';
+import type { ViteBuildContext } from '../../types';
+import { getWarmupClientFiles } from '../get-warmup-client-files';
+
+describe(getWarmupClientFiles.name, () => {
+    const destination = 'dist';
+    let context: ViteBuildContext;
+    let outputRoot: string;
+
+    beforeEach(() => {
+        context = { build: {}, package: { destination } } as unknown as ViteBuildContext;
+        outputRoot = path.join(process.cwd(), destination, 'bundle');
+    });
+
+    const subject = () => getWarmupClientFiles(context, outputRoot);
+
+    test('returns compiled output, excluding the bundle output', () => {
+        expect(subject()).toEqual([`${destination}/**/*.js`, `!${destination}/bundle/**`]);
+    });
+});

package/src/vite/config/__tests__/load-config-file.test.ts

@@ -0,0 +1,191 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { rolldown } from 'rolldown'; // eslint-disable-line import/no-extraneous-dependencies
+import type { BuildContext } from '../../../core/types';
+import { loadConfigFile } from '../load-config-file';
+
+jest.mock('rolldown', () => ({ rolldown: jest.fn() }));
+
+describe('[startup] loadConfigFile', () => {
+    const emptyModule = 'module.exports = {};';
+    const config = { foo: 'bar' };
+
+    let root: string;
+    let context: BuildContext;
+
+    beforeAll(() => (root = fs.mkdtempSync(path.join(os.tmpdir(), 'startup-test-'))));
+    afterAll(() => fs.rmSync(root, { recursive: true, force: true }));
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        context = { build: { isProduction: true } } as BuildContext;
+    });
+
+    function setup({
+        configFiles,
+        generatedOutput = emptyModule,
+    }: {
+        configFiles: string[];
+        generatedOutput?: string;
+    }) {
+        for (const entry of fs.readdirSync(root)) {
+            fs.rmSync(path.join(root, entry), { recursive: true, force: true });
+        }
+        for (const file of configFiles) {
+            fs.writeFileSync(path.join(root, file), '');
+        }
+        jest.mocked(rolldown).mockResolvedValue({
+            generate: jest.fn().mockResolvedValue({ output: [{ code: generatedOutput }] }),
+        } as any);
+    }
+
+    function cjsExport(value: Record<string, any>) {
+        return `module.exports = ${JSON.stringify(value)};`;
+    }
+
+    const subject = () => loadConfigFile(root, context);
+
+    function itReturnsEmptyObject() {
+        test('returns empty object', async () => {
+            expect(await subject()).toEqual({});
+        });
+    }
+
+    itReturnsEmptyObject();
+
+    test('does not call rolldown', async () => {
+        await subject();
+
+        expect(rolldown).not.toHaveBeenCalled();
+    });
+
+    describe('with a prod config file', () => {
+        const prodConfigTs = 'vite.prod.config.ts';
+        const prodConfigJs = 'vite.prod.config.js';
+
+        beforeEach(() => {
+            setup({ configFiles: [prodConfigTs], generatedOutput: cjsExport(config) });
+        });
+
+        test('returns the config', async () => {
+            expect(await subject()).toEqual(config);
+        });
+
+        test('passes the config path to rolldown', async () => {
+            await subject();
+
+            expect(rolldown).toHaveBeenCalledWith(
+                expect.objectContaining({ input: path.join(root, prodConfigTs) })
+            );
+        });
+
+        test('generates CJS output', async () => {
+            await subject();
+
+            const { generate } = (await jest.mocked(rolldown).mock.results[0].value) as any;
+            expect(generate).toHaveBeenCalledWith({ format: 'cjs' });
+        });
+
+        test('externalizes bare imports and keeps relative/absolute paths', async () => {
+            await subject();
+
+            const { external } = jest.mocked(rolldown).mock.calls[0][0] as any;
+            expect(external('lodash')).toBe(true);
+            expect(external('@servicetitan/startup')).toBe(true);
+            expect(external('./shared-config')).toBe(false);
+            expect(external('/Users/dev/project/shared-config.ts')).toBe(false);
+        });
+
+        function itCleansTempFile() {
+            test('cleans up temp file', async () => {
+                await subject().catch(() => {});
+
+                const tmpDir = path.join(root, 'node_modules', '.startup');
+                const files = fs.existsSync(tmpDir) ? fs.readdirSync(tmpDir) : [];
+                expect(files).toHaveLength(0);
+            });
+        }
+
+        itCleansTempFile();
+
+        describe('when import throws', () => {
+            beforeEach(() => {
+                setup({
+                    configFiles: [prodConfigTs],
+                    generatedOutput: 'throw new Error("bad config");',
+                });
+            });
+
+            itCleansTempFile();
+        });
+
+        describe('when config exports a function', () => {
+            beforeEach(() => {
+                setup({
+                    configFiles: [prodConfigTs],
+                    generatedOutput:
+                        'module.exports = (ctx) => ({ config: { minify: ctx.build.isProduction } });',
+                });
+            });
+
+            test('returns the result of calling the function', async () => {
+                expect(await subject()).toEqual({ config: { minify: true } });
+            });
+        });
+
+        describe('when config exports null', () => {
+            beforeEach(() => {
+                setup({ configFiles: [prodConfigTs], generatedOutput: 'module.exports = null;' });
+            });
+
+            itReturnsEmptyObject();
+        });
+
+        describe('when .js also exists', () => {
+            beforeEach(() => {
+                setup({ configFiles: [prodConfigTs, prodConfigJs] });
+            });
+
+            test('prefers .ts over .js', async () => {
+                await subject();
+
+                expect(rolldown).toHaveBeenCalledWith(
+                    expect.objectContaining({ input: path.join(root, prodConfigTs) })
+                );
+            });
+        });
+
+        describe('when only .js exists', () => {
+            beforeEach(() => {
+                setup({ configFiles: [prodConfigJs] });
+            });
+
+            test('loads .js config', async () => {
+                await subject();
+
+                expect(rolldown).toHaveBeenCalledWith(
+                    expect.objectContaining({ input: path.join(root, prodConfigJs) })
+                );
+            });
+        });
+    });
+
+    describe('with a dev config file', () => {
+        const devConfigTs = 'vite.dev.config.ts';
+
+        beforeEach(() => {
+            setup({ configFiles: [devConfigTs], generatedOutput: cjsExport(config) });
+        });
+
+        itReturnsEmptyObject();
+
+        describe('with dev context', () => {
+            beforeEach(() => (context.build.isProduction = false));
+
+            test('returns the config', async () => {
+                expect(await subject()).toEqual(config);
+            });
+        });
+    });
+});

package/src/vite/config/__tests__/merge-vite-configs.test.ts

@@ -0,0 +1,84 @@
+import type { VitePackageJsonOverride } from '../../../utils/get-configuration';
+import type { ViteConfigFileOverride } from '../define-config';
+
+jest.mock('vite', () => ({
+    mergeConfig: (a: Record<string, any>, b: Record<string, any>) => ({ ...a, ...b }),
+}));
+
+import { mergeViteConfigs } from '../merge-vite-configs';
+
+describe(mergeViteConfigs.name, () => {
+    const baseConfig = {
+        root: '/app',
+        build: { outDir: 'dist' },
+    };
+
+    let packageJsonConfig: VitePackageJsonOverride;
+    let fileConfig: ViteConfigFileOverride;
+
+    beforeEach(() => {
+        packageJsonConfig = {};
+        fileConfig = {};
+    });
+
+    const subject = () => mergeViteConfigs(baseConfig, packageJsonConfig, fileConfig);
+
+    test('returns base config', () => {
+        expect(subject()).toEqual(baseConfig);
+    });
+
+    describe('when package.json has config', () => {
+        beforeEach(() => {
+            packageJsonConfig = { config: { server: { port: 3000 } } };
+        });
+
+        test('merges into base', () => {
+            expect(subject()).toEqual({
+                ...baseConfig,
+                server: { port: 3000 },
+            });
+        });
+    });
+
+    describe('when config file has config', () => {
+        beforeEach(() => {
+            fileConfig = { config: { server: { port: 4000 } } };
+        });
+
+        test('merges into base', () => {
+            expect(subject()).toEqual({
+                ...baseConfig,
+                server: { port: 4000 },
+            });
+        });
+    });
+
+    describe('when both package.json and config file have config', () => {
+        beforeEach(() => {
+            packageJsonConfig = { config: { server: { port: 3000 } } };
+            fileConfig = { config: { server: { port: 4000 } } };
+        });
+
+        test('file config takes precedence', () => {
+            expect(subject()).toEqual({
+                ...baseConfig,
+                server: { port: 4000 },
+            });
+        });
+    });
+
+    describe('when configs have non-overlapping keys', () => {
+        beforeEach(() => {
+            packageJsonConfig = { config: { resolve: { alias: { '@': '/src' } } } };
+            fileConfig = { config: { server: { port: 4000 } } };
+        });
+
+        test('merges all three together', () => {
+            expect(subject()).toEqual({
+                ...baseConfig,
+                resolve: { alias: { '@': '/src' } },
+                server: { port: 4000 },
+            });
+        });
+    });
+});

package/src/vite/config/asset-file-names.ts

@@ -0,0 +1,20 @@
+import {
+    FONT_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    SVG_EXTENSIONS,
+    createExtensionRegExp,
+} from '../../core';
+
+const FONT = createExtensionRegExp(FONT_EXTENSIONS);
+const IMAGE = createExtensionRegExp([...IMAGE_EXTENSIONS, ...SVG_EXTENSIONS]);
+
+export function assetFileNames(asset: { names: string[] }): string {
+    const name = asset.names[0] ?? '';
+    if (FONT.test(name)) {
+        return 'fonts/[name]-[hash][extname]';
+    }
+    if (IMAGE.test(name)) {
+        return 'images/[name]-[hash][extname]';
+    }
+    return 'assets/[name]-[hash][extname]';
+}