@servicetitan/startup 36.0.0 → 36.1.1-beta.1

package/src/vite/plugins/__tests__/dev-server-routing-plugin.test.ts

@@ -0,0 +1,255 @@
+import { fs, vol } from 'memfs';
+import path from 'path';
+import { type BuildContext, getBundleType } from '../../../core';
+import { log } from '../../../utils';
+import { devServerRoutingPlugin } from '../dev-server-routing-plugin';
+
+jest.mock('fs', () => fs);
+jest.mock('../../../core', () => ({
+    getBundleType: jest.fn(),
+}));
+jest.mock('../../../utils', () => ({
+    log: { info: jest.fn(), timestamp: '00:00:00' },
+}));
+
+describe(devServerRoutingPlugin.name, () => {
+    const SHARED_DEPS_DIR = 'shared';
+    const destination = 'dist/bundle/full';
+    const destDir = path.resolve(destination);
+    const outDir = path.resolve('dist/bundle/full');
+    const outDirRelative = path.relative(process.cwd(), outDir);
+
+    let context: BuildContext;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        vol.fromJSON({});
+        jest.mocked(getBundleType).mockReturnValue(SHARED_DEPS_DIR);
+        context = {
+            build: { name: 'test-app' },
+            package: { destination },
+        } as BuildContext;
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        vol.reset();
+    });
+
+    const subject = () => devServerRoutingPlugin(context);
+
+    test('returns plugin with correct name', () => {
+        expect(subject().name).toBe('dev-server-routing');
+    });
+
+    const setupMiddleware = (resolvedOutDir: string) => {
+        const plugin = subject();
+        (plugin.configResolved as Function).call(plugin, {
+            build: { outDir: resolvedOutDir },
+        });
+
+        let middleware!: Function;
+        const server: any = {
+            middlewares: {
+                use: (handler: Function) => (middleware = handler),
+            },
+        };
+        (plugin.configureServer as Function).call(plugin, server);
+        return middleware;
+    };
+
+    describe('configResolved', () => {
+        test('captures outDir for use by configureServer', () => {
+            const middleware = setupMiddleware(outDir);
+            const req: any = { url: `/${SHARED_DEPS_DIR}/dep.js` };
+            const originalUrl = req.url;
+
+            middleware(req, {}, jest.fn());
+
+            expect(req.url).toBe(`/${outDirRelative}/${originalUrl.slice(1)}`);
+        });
+    });
+
+    describe('configureServer', () => {
+        const itPreservesUnmatchedUrls = () => {
+            test('preserves unmatched URL', () => {
+                const middleware = setupMiddleware(outDir);
+                const req: any = { url: '/other/path' };
+                const originalUrl = req.url;
+
+                middleware(req, {}, jest.fn());
+
+                expect(req.url).toBe(originalUrl);
+            });
+        };
+
+        test('logs request', () => {
+            const middleware = setupMiddleware(outDir);
+
+            middleware({ method: 'GET', url: '/anything' }, {}, jest.fn());
+
+            expect(log.info).toHaveBeenCalled();
+        });
+
+        test('calls next middleware', () => {
+            const middleware = setupMiddleware(outDir);
+            const next = jest.fn();
+
+            middleware({ url: '/anything' }, {}, next);
+
+            expect(next).toHaveBeenCalled();
+        });
+
+        describe('when package is a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = true));
+
+            test('strips outDir prefix from URL', () => {
+                const middleware = setupMiddleware(outDir);
+                const req: any = { url: `/${outDirRelative}/index.js` };
+
+                middleware(req, {}, jest.fn());
+
+                expect(req.url).toBe('/index.js');
+            });
+
+            itPreservesUnmatchedUrls();
+        });
+
+        describe('when package is not a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = false));
+
+            test('rewrites shared dependencies URL to outDir', () => {
+                const middleware = setupMiddleware(outDir);
+                const req: any = { url: `/${SHARED_DEPS_DIR}/dep.js` };
+
+                middleware(req, {}, jest.fn());
+
+                expect(req.url).toBe(`/${outDirRelative}/${SHARED_DEPS_DIR}/dep.js`);
+            });
+
+            itPreservesUnmatchedUrls();
+        });
+    });
+
+    describe('configurePreviewServer', () => {
+        const setupPreviewServer = () => {
+            const plugin = subject();
+            const uses: { path?: string; handler: Function }[] = [];
+            const server: any = {
+                middlewares: {
+                    use: (...args: any[]) => {
+                        if (typeof args[0] === 'string') {
+                            uses.push({ path: args[0], handler: args[1] });
+                        } else {
+                            uses.push({ handler: args[0] });
+                        }
+                    },
+                },
+            };
+            (plugin.configurePreviewServer as Function).call(plugin, server);
+            return {
+                logger: uses.find(u => !u.path)!.handler,
+                staticFiles: uses.find(u => u.path)?.handler,
+            };
+        };
+
+        test('logs request and calls next middleware', () => {
+            const { logger } = setupPreviewServer();
+            const req = { method: 'GET', url: '/index.html' };
+            const next = jest.fn();
+
+            logger(req, {}, next);
+
+            expect(log.info).toHaveBeenCalled();
+            expect(next).toHaveBeenCalled();
+        });
+
+        describe('when package is not a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = false));
+
+            test('only registers logging middleware', () => {
+                const { logger, staticFiles } = setupPreviewServer();
+
+                expect(logger).toBeDefined();
+                expect(staticFiles).toBeUndefined();
+            });
+        });
+
+        describe('when package is a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = true));
+
+            const serveStaticFile = (fileName: string) => {
+                const mockStream = { pipe: jest.fn() };
+                jest.spyOn(fs, 'createReadStream').mockReturnValue(mockStream as any);
+                const { staticFiles } = setupPreviewServer();
+                const res = { setHeader: jest.fn() };
+                staticFiles!({ url: `/${fileName}` }, res, jest.fn());
+                return { res, mockStream };
+            };
+
+            describe.each([
+                ['file.js', 'application/javascript'],
+                ['file.css', 'text/css'],
+                ['file.json', 'application/json'],
+            ])('when requested file is %s', (fileName, contentType) => {
+                beforeEach(() => {
+                    vol.fromJSON({ [path.join(destDir, fileName)]: 'content' });
+                });
+
+                test(`serves file as ${contentType}`, () => {
+                    const { res, mockStream } = serveStaticFile(fileName);
+
+                    expect(res.setHeader).toHaveBeenCalledWith('Content-Type', contentType);
+                    expect(mockStream.pipe).toHaveBeenCalledWith(res);
+                });
+            });
+
+            describe('when requested file has unrecognized extension', () => {
+                const fileName = 'file.txt';
+
+                beforeEach(() => {
+                    vol.fromJSON({ [path.join(destDir, fileName)]: 'content' });
+                });
+
+                test('serves file without content type', () => {
+                    const { res, mockStream } = serveStaticFile(fileName);
+
+                    expect(res.setHeader).not.toHaveBeenCalled();
+                    expect(mockStream.pipe).toHaveBeenCalledWith(res);
+                });
+            });
+
+            describe('when requested file does not exist', () => {
+                beforeEach(() => vol.reset());
+
+                test('calls next middleware', () => {
+                    const { staticFiles } = setupPreviewServer();
+                    const next = jest.fn();
+
+                    staticFiles!({ url: '/missing.js' }, {}, next);
+
+                    expect(next).toHaveBeenCalled();
+                });
+            });
+
+            describe('when requested URL traverses outside the mounted directory', () => {
+                beforeEach(() => {
+                    vol.fromJSON({
+                        [path.resolve(destDir, '../outside.js')]: 'content',
+                    });
+                });
+
+                test('does not serve the file', () => {
+                    const createReadStream = jest.spyOn(fs, 'createReadStream');
+                    const { staticFiles } = setupPreviewServer();
+                    const next = jest.fn();
+
+                    staticFiles!({ url: '/../outside.js' }, {}, next);
+
+                    expect(next).toHaveBeenCalled();
+                    expect(createReadStream).not.toHaveBeenCalled();
+                });
+            });
+        });
+    });
+});

package/src/vite/plugins/__tests__/externals-plugin.test.ts

@@ -0,0 +1,138 @@
+import { fs, vol } from 'memfs';
+import path from 'path';
+import { type BuildContext, getExternals } from '../../../core';
+import { externalsPlugin } from '../externals-plugin';
+
+jest.mock('fs', () => fs);
+jest.mock('../../../core', () => ({
+    getExternals: jest.fn(),
+}));
+
+describe(externalsPlugin.name, () => {
+    const mockExternals: Record<string, string> = {
+        'react': 'globalReact',
+        '@scope/lib': 'globalScopeLib',
+    };
+    const proxyNodeModules = path.resolve('node_modules', '.startup', 'externals', 'node_modules');
+
+    let context: BuildContext;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        vol.fromJSON({});
+        jest.mocked(getExternals).mockReturnValue(mockExternals);
+        context = {
+            build: {},
+        } as BuildContext;
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => externalsPlugin(context);
+
+    test('returns plugin with correct name', () => {
+        expect(subject()!.name).toBe('externals');
+    });
+
+    test('enforces pre', () => {
+        expect(subject()!.enforce).toBe('pre');
+    });
+
+    test('writes proxy CJS module for each dependency', () => {
+        subject();
+
+        for (const [dependency, proxy] of Object.entries(mockExternals)) {
+            const cjsPath = path.join(proxyNodeModules, dependency, 'index.cjs');
+            expect(fs.readFileSync(cjsPath, 'utf8')).toBe(`module.exports = ${proxy};`);
+        }
+    });
+
+    test('writes proxy package.json for each dependency', () => {
+        subject();
+
+        for (const [dependency] of Object.entries(mockExternals)) {
+            const pkgPath = path.join(proxyNodeModules, dependency, 'package.json');
+            expect(JSON.parse(fs.readFileSync(pkgPath, 'utf8') as string)).toEqual({
+                name: dependency,
+                main: './index.cjs',
+            });
+        }
+    });
+
+    describe('when no externals exist', () => {
+        beforeEach(() => jest.mocked(getExternals).mockReturnValue(undefined));
+
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+    });
+
+    describe('when build is production', () => {
+        beforeEach(() => (context.build.isProduction = true));
+
+        describe('resolveId', () => {
+            let source: string;
+
+            const subject = () => {
+                const plugin = externalsPlugin(context)!;
+                return (plugin.resolveId as Function).call(plugin, source);
+            };
+
+            describe('with known dependency', () => {
+                const knownDependency = Object.keys(mockExternals)[0];
+
+                beforeEach(() => (source = knownDependency));
+
+                test('resolves to proxy module', () => {
+                    expect(subject()).toBe(
+                        path.join(proxyNodeModules, knownDependency, 'index.cjs')
+                    );
+                });
+            });
+
+            describe('with unknown dependency', () => {
+                beforeEach(() => (source = 'unknown'));
+
+                test('returns undefined', () => {
+                    expect(subject()).toBeUndefined();
+                });
+            });
+        });
+
+        test('does not define config', () => {
+            expect(subject()!.config).toBeUndefined();
+        });
+    });
+
+    describe('when build is not production', () => {
+        beforeEach(() => (context.build.isProduction = false));
+
+        describe('config', () => {
+            const subject = () => {
+                const plugin = externalsPlugin(context)!;
+                return (plugin.config as Function).call(plugin);
+            };
+
+            test('returns resolve aliases for each dependency', () => {
+                expect(subject().resolve.alias).toEqual([
+                    {
+                        find: /^react$/,
+                        replacement: path.join(proxyNodeModules, 'react'),
+                    },
+                    {
+                        find: /^@scope\/lib$/,
+                        replacement: path.join(proxyNodeModules, '@scope/lib'),
+                    },
+                ]);
+            });
+
+            test('includes dependencies in optimizeDeps', () => {
+                expect(subject().optimizeDeps.include).toEqual(Object.keys(mockExternals));
+            });
+        });
+
+        test('does not define resolveId', () => {
+            expect(subject()!.resolveId).toBeUndefined();
+        });
+    });
+});

package/src/vite/plugins/__tests__/html-plugin.test.ts

@@ -0,0 +1,308 @@
+import { Eta } from 'eta';
+import { fs, vol } from 'memfs';
+import path from 'path';
+import { getSharedEntryPoints } from '../../../core';
+import type { ViteBuildContext } from '../../types';
+import { htmlPlugin } from '../html-plugin';
+
+const mockRender = jest.fn();
+
+jest.mock('fs', () => fs);
+jest.mock('eta', () => ({
+    Eta: jest.fn(() => ({ render: mockRender })),
+}));
+jest.mock('../../../core', () => ({
+    getSharedEntryPoints: jest.fn(),
+}));
+
+describe(htmlPlugin.name, () => {
+    const VIRTUAL_HTML_PATH = path.resolve('index.html');
+    const RENDERED_HTML = '<html><body>rendered</body></html>';
+
+    let context: ViteBuildContext;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        vol.fromJSON({});
+        mockRender.mockReturnValue(RENDERED_HTML);
+        jest.mocked(getSharedEntryPoints).mockReturnValue({ css: [], js: [] });
+        context = {
+            build: { name: 'my-app', isProduction: false },
+            package: { isWebComponent: false },
+            bundlerConfig: {
+                pluginOverrides: {
+                    html: { template: '/templates/custom.html' },
+                },
+            },
+        } as ViteBuildContext;
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => htmlPlugin(context);
+
+    test('returns plugin with correct name', () => {
+        expect(subject().name).toBe('html');
+    });
+
+    test('constructs Eta with template directory', () => {
+        subject();
+
+        const templateDir = path.dirname(
+            path.resolve(context.bundlerConfig.pluginOverrides.html!.template!)
+        );
+        expect(Eta).toHaveBeenCalledWith({ views: templateDir });
+    });
+
+    describe('when template is not configured', () => {
+        beforeEach(() => {
+            context.bundlerConfig.pluginOverrides.html = undefined as any;
+        });
+
+        test('constructs Eta with default template directory', () => {
+            subject();
+
+            const defaultTemplateDir = path.resolve(__dirname, '../..');
+            expect(Eta).toHaveBeenCalledWith({ views: defaultTemplateDir });
+        });
+    });
+
+    describe('resolveId', () => {
+        let source: string;
+        let importer: string | undefined;
+
+        beforeEach(() => {
+            source = './app';
+            importer = undefined;
+        });
+
+        const subject = () => {
+            const plugin = htmlPlugin(context);
+            return (plugin.resolveId as Function).call(plugin, source, importer);
+        };
+
+        const itReturnsUndefined = () => {
+            test('returns undefined', () => {
+                expect(subject()).toBeUndefined();
+            });
+        };
+
+        itReturnsUndefined();
+
+        describe('when source is virtual HTML path', () => {
+            beforeEach(() => (source = VIRTUAL_HTML_PATH));
+
+            test('returns source', () => {
+                expect(subject()).toBe(VIRTUAL_HTML_PATH);
+            });
+        });
+
+        describe('when importer includes index.html', () => {
+            beforeEach(() => (importer = VIRTUAL_HTML_PATH));
+
+            itReturnsUndefined();
+
+            describe('when source JS file exists', () => {
+                let sourcePath: string;
+
+                beforeEach(() => {
+                    sourcePath = path.resolve(source + '.js');
+                    vol.fromJSON({ [sourcePath]: '' });
+                });
+
+                test('resolves to .js path', () => {
+                    expect(subject()).toBe(sourcePath);
+                });
+
+                describe('when source is not relative path', () => {
+                    beforeEach(() => {
+                        source = 'react';
+                        sourcePath = path.resolve(source + '.js');
+                        vol.fromJSON({ [sourcePath]: '' });
+                    });
+
+                    itReturnsUndefined();
+                });
+            });
+        });
+    });
+
+    describe('load', () => {
+        let id: string;
+
+        beforeEach(() => (id = ''));
+
+        const subject = () => {
+            const plugin = htmlPlugin(context);
+            return (plugin.load as Function).call(plugin, id);
+        };
+
+        test('does nothing', () => {
+            subject();
+
+            expect(mockRender).not.toHaveBeenCalled();
+        });
+
+        describe('when id is virtual HTML path', () => {
+            beforeEach(() => (id = VIRTUAL_HTML_PATH));
+            test('returns rendered HTML', () => {
+                expect(subject()).toBe(RENDERED_HTML);
+            });
+
+            test('passes context values to template', () => {
+                subject();
+
+                const templateName = path.basename(
+                    context.bundlerConfig.pluginOverrides.html!.template!
+                );
+                expect(mockRender).toHaveBeenCalledWith(templateName, {
+                    title: 'ServiceTitan',
+                    favicon: undefined,
+                    css: [],
+                    js: [],
+                    isProduction: context.build.isProduction,
+                    isWebComponent: context.package.isWebComponent,
+                    name: context.build.name,
+                });
+            });
+
+            describe('when title is overridden', () => {
+                beforeEach(() => {
+                    context.bundlerConfig.pluginOverrides.html!.title = 'Custom Title';
+                });
+
+                test('passes overridden title to template', () => {
+                    subject();
+
+                    expect(mockRender).toHaveBeenCalledWith(
+                        expect.anything(),
+                        expect.objectContaining({ title: 'Custom Title' })
+                    );
+                });
+            });
+
+            describe('when favicon is overridden', () => {
+                beforeEach(() => {
+                    context.bundlerConfig.pluginOverrides.html!.favicon = '/favicon.ico';
+                });
+
+                test('passes overridden favicon to template', () => {
+                    subject();
+
+                    expect(mockRender).toHaveBeenCalledWith(
+                        expect.anything(),
+                        expect.objectContaining({ favicon: '/favicon.ico' })
+                    );
+                });
+            });
+        });
+    });
+
+    describe('configResolved', () => {
+        const publicDir = path.resolve('public');
+
+        const subject = () => {
+            const plugin = htmlPlugin(context);
+            (plugin.configResolved as Function).call(plugin, { publicDir });
+            (plugin.load as Function).call(plugin, VIRTUAL_HTML_PATH);
+        };
+
+        test('ignores favicon', () => {
+            subject();
+
+            expect(mockRender).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.objectContaining({ favicon: undefined })
+            );
+        });
+
+        describe('when public directory contains favicon.ico', () => {
+            beforeEach(() => {
+                vol.fromJSON({ [path.join(publicDir, 'favicon.ico')]: '' });
+            });
+
+            test('configures favicon', () => {
+                subject();
+
+                expect(mockRender).toHaveBeenCalledWith(
+                    expect.anything(),
+                    expect.objectContaining({ favicon: '/favicon.ico' })
+                );
+            });
+
+            describe('when favicon is explicitly configured', () => {
+                const favicon = '/custom.ico';
+                beforeEach(() => {
+                    context.bundlerConfig.pluginOverrides.html!.favicon = favicon;
+                });
+
+                test('uses configured value', () => {
+                    subject();
+
+                    expect(mockRender).toHaveBeenCalledWith(
+                        expect.anything(),
+                        expect.objectContaining({ favicon })
+                    );
+                });
+            });
+        });
+    });
+
+    describe('configureServer', () => {
+        const TRANSFORMED_HTML = '<html>transformed</html>';
+
+        let req: any;
+        let res: any;
+        let next: jest.Mock;
+        let server: any;
+
+        beforeEach(() => {
+            req = { url: '/other' };
+            res = { end: jest.fn() };
+            next = jest.fn();
+
+            const plugin = htmlPlugin(context);
+            server = {
+                middlewares: { use: jest.fn() },
+                transformIndexHtml: jest.fn(() => Promise.resolve(TRANSFORMED_HTML)),
+            };
+            const postHook = (plugin.configureServer as Function).call(plugin, server);
+            postHook();
+        });
+
+        const subject = async () => {
+            const middleware = server.middlewares.use.mock.calls[0][0];
+            await middleware(req, res, next);
+        };
+
+        test('calls next middleware', async () => {
+            await subject();
+
+            expect(next).toHaveBeenCalled();
+        });
+
+        test('does not serve transformed HTML', async () => {
+            await subject();
+
+            expect(server.transformIndexHtml).not.toHaveBeenCalled();
+            expect(res.end).not.toHaveBeenCalled();
+        });
+
+        describe('when request URL ends with index.html', () => {
+            beforeEach(() => (req.url = '/index.html'));
+
+            test('serves transformed HTML', async () => {
+                await subject();
+
+                expect(server.transformIndexHtml).toHaveBeenCalledWith(req.url, RENDERED_HTML);
+                expect(res.end).toHaveBeenCalledWith(TRANSFORMED_HTML);
+            });
+
+            test('does not call next middleware', async () => {
+                await subject();
+
+                expect(next).not.toHaveBeenCalled();
+            });
+        });
+    });
+});