@servicetitan/startup 37.0.2 → 38.1.0

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

@@ -1,10 +1,12 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
+import { normalizePath } from 'vite';
 import { type BuildContext, getBundleType } from '../../../core';
 import { log } from '../../../utils';
 import { devServerRoutingPlugin } from '../dev-server-routing-plugin';
 
 jest.mock('fs', () => fs);
+jest.mock('vite', () => ({ normalizePath: jest.fn() }));
 jest.mock('../../../core', () => ({
     getBundleType: jest.fn(),
 }));
@@ -16,8 +18,6 @@ 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;
 
@@ -25,6 +25,7 @@ describe(devServerRoutingPlugin.name, () => {
         jest.clearAllMocks();
         vol.fromJSON({});
         jest.mocked(getBundleType).mockReturnValue(SHARED_DEPS_DIR);
+        jest.mocked(normalizePath).mockImplementation(id => id.split('\\').join('/'));
         context = {
             build: { name: 'test-app' },
             package: { destination },
@@ -39,92 +40,94 @@ describe(devServerRoutingPlugin.name, () => {
     const subject = () => devServerRoutingPlugin(context);
 
     test('returns plugin with correct name', () => {
-        expect(subject().name).toBe('dev-server-routing');
+        expect(subject().name).toBe('st: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('configureServer', () => {
+        let req: any;
+        let next: jest.Mock;
+        let middleware: Function;
 
-    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;
+        const setupMiddleware = () => {
+            const plugin = devServerRoutingPlugin(context);
+            (plugin.configResolved as Function).call(plugin, { build: { outDir: destDir } });
 
-            middleware(req, {}, jest.fn());
+            const server: any = {
+                middlewares: { use: (handler: Function) => (middleware = handler) },
+            };
+            (plugin.configureServer as Function).call(plugin, server);
+        };
 
-            expect(req.url).toBe(`/${outDirRelative}/${originalUrl.slice(1)}`);
+        beforeEach(() => {
+            req = { method: 'GET', url: '/anything' };
+            next = jest.fn();
+            setupMiddleware();
         });
-    });
-
-    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);
-            });
-        };
+        const subject = () => middleware(req, {}, next);
 
         test('logs request', () => {
-            const middleware = setupMiddleware(outDir);
-
-            middleware({ method: 'GET', url: '/anything' }, {}, jest.fn());
+            subject();
 
             expect(log.info).toHaveBeenCalled();
         });
 
         test('calls next middleware', () => {
-            const middleware = setupMiddleware(outDir);
-            const next = jest.fn();
-
-            middleware({ url: '/anything' }, {}, next);
+            subject();
 
             expect(next).toHaveBeenCalled();
         });
 
+        const itPreservesUnmatchedUrls = () => {
+            describe('with an unmatched URL', () => {
+                let originalUrl: string;
+
+                beforeEach(() => {
+                    req.url = '/other/path';
+                    originalUrl = req.url;
+                });
+
+                test('preserves the URL', () => {
+                    subject();
+
+                    expect(req.url).toBe(originalUrl);
+                });
+            });
+        };
+
         describe('when package is a web component', () => {
-            beforeEach(() => (context.package.isWebComponent = true));
+            beforeEach(() => {
+                context.package.isWebComponent = true;
+                setupMiddleware();
+            });
 
-            test('strips outDir prefix from URL', () => {
-                const middleware = setupMiddleware(outDir);
-                const req: any = { url: `/${outDirRelative}/index.js` };
+            describe('with a URL under outDir', () => {
+                beforeEach(() => (req.url = `/${destination}/index.js`));
 
-                middleware(req, {}, jest.fn());
+                test('strips outDir prefix from URL', () => {
+                    subject();
 
-                expect(req.url).toBe('/index.js');
+                    expect(req.url).toBe('/index.js');
+                });
             });
 
             itPreservesUnmatchedUrls();
         });
 
         describe('when package is not a web component', () => {
-            beforeEach(() => (context.package.isWebComponent = false));
+            beforeEach(() => {
+                context.package.isWebComponent = false;
+                setupMiddleware();
+            });
 
-            test('rewrites shared dependencies URL to outDir', () => {
-                const middleware = setupMiddleware(outDir);
-                const req: any = { url: `/${SHARED_DEPS_DIR}/dep.js` };
+            describe('with a shared dependency URL', () => {
+                beforeEach(() => (req.url = `/${SHARED_DEPS_DIR}/dep.js`));
 
-                middleware(req, {}, jest.fn());
+                test('rewrites URL to outDir', () => {
+                    subject();
 
-                expect(req.url).toBe(`/${outDirRelative}/${SHARED_DEPS_DIR}/dep.js`);
+                    expect(req.url).toBe(`/${destination}/${SHARED_DEPS_DIR}/dep.js`);
+                });
             });
 
             itPreservesUnmatchedUrls();
@@ -132,8 +135,8 @@ describe(devServerRoutingPlugin.name, () => {
     });
 
     describe('configurePreviewServer', () => {
-        const setupPreviewServer = () => {
-            const plugin = subject();
+        const registerPreviewServer = () => {
+            const plugin = devServerRoutingPlugin(context);
             const uses: { path?: string; handler: Function }[] = [];
             const server: any = {
                 middlewares: {
@@ -153,39 +156,66 @@ describe(devServerRoutingPlugin.name, () => {
             };
         };
 
-        test('logs request and calls next middleware', () => {
-            const { logger } = setupPreviewServer();
-            const req = { method: 'GET', url: '/index.html' };
-            const next = jest.fn();
+        describe('logging middleware', () => {
+            let req: any;
+            let next: jest.Mock;
+            let logger: Function;
 
-            logger(req, {}, next);
+            beforeEach(() => {
+                ({ logger } = registerPreviewServer());
+                req = { method: 'GET', url: '/index.html' };
+                next = jest.fn();
+            });
 
-            expect(log.info).toHaveBeenCalled();
-            expect(next).toHaveBeenCalled();
+            const subject = () => logger(req, {}, next);
+
+            test('logs request', () => {
+                subject();
+
+                expect(log.info).toHaveBeenCalled();
+            });
+
+            test('calls next middleware', () => {
+                subject();
+
+                expect(next).toHaveBeenCalled();
+            });
         });
 
         describe('when package is not a web component', () => {
-            beforeEach(() => (context.package.isWebComponent = false));
+            let staticFiles: Function | undefined;
 
-            test('only registers logging middleware', () => {
-                const { logger, staticFiles } = setupPreviewServer();
+            beforeEach(() => {
+                context.package.isWebComponent = false;
+                ({ staticFiles } = registerPreviewServer());
+            });
 
-                expect(logger).toBeDefined();
+            test('does not register a static file middleware', () => {
                 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 };
-            };
+            let req: any;
+            let res: any;
+            let next: jest.Mock;
+            let mockStream: { pipe: jest.Mock };
+            let createReadStreamSpy: jest.SpyInstance;
+            let staticFiles: Function | undefined;
+
+            beforeEach(() => {
+                context.package.isWebComponent = true;
+                mockStream = { pipe: jest.fn() };
+                createReadStreamSpy = jest
+                    .spyOn(fs, 'createReadStream')
+                    .mockReturnValue(mockStream as any);
+                ({ staticFiles } = registerPreviewServer());
+                req = { url: '/file.js' };
+                res = { setHeader: jest.fn() };
+                next = jest.fn();
+            });
+
+            const subject = () => staticFiles!(req, res, next);
 
             describe.each([
                 ['file.js', 'application/javascript'],
@@ -193,11 +223,12 @@ describe(devServerRoutingPlugin.name, () => {
                 ['file.json', 'application/json'],
             ])('when requested file is %s', (fileName, contentType) => {
                 beforeEach(() => {
+                    req.url = `/${fileName}`;
                     vol.fromJSON({ [path.join(destDir, fileName)]: 'content' });
                 });
 
                 test(`serves file as ${contentType}`, () => {
-                    const { res, mockStream } = serveStaticFile(fileName);
+                    subject();
 
                     expect(res.setHeader).toHaveBeenCalledWith('Content-Type', contentType);
                     expect(mockStream.pipe).toHaveBeenCalledWith(res);
@@ -205,14 +236,13 @@ describe(devServerRoutingPlugin.name, () => {
             });
 
             describe('when requested file has unrecognized extension', () => {
-                const fileName = 'file.txt';
-
                 beforeEach(() => {
-                    vol.fromJSON({ [path.join(destDir, fileName)]: 'content' });
+                    req.url = '/file.txt';
+                    vol.fromJSON({ [path.join(destDir, 'file.txt')]: 'content' });
                 });
 
                 test('serves file without content type', () => {
-                    const { res, mockStream } = serveStaticFile(fileName);
+                    subject();
 
                     expect(res.setHeader).not.toHaveBeenCalled();
                     expect(mockStream.pipe).toHaveBeenCalledWith(res);
@@ -220,13 +250,10 @@ describe(devServerRoutingPlugin.name, () => {
             });
 
             describe('when requested file does not exist', () => {
-                beforeEach(() => vol.reset());
+                beforeEach(() => (req.url = '/missing.js'));
 
                 test('calls next middleware', () => {
-                    const { staticFiles } = setupPreviewServer();
-                    const next = jest.fn();
-
-                    staticFiles!({ url: '/missing.js' }, {}, next);
+                    subject();
 
                     expect(next).toHaveBeenCalled();
                 });
@@ -234,20 +261,15 @@ describe(devServerRoutingPlugin.name, () => {
 
             describe('when requested URL traverses outside the mounted directory', () => {
                 beforeEach(() => {
-                    vol.fromJSON({
-                        [path.resolve(destDir, '../outside.js')]: 'content',
-                    });
+                    req.url = '/../outside.js';
+                    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);
+                    subject();
 
                     expect(next).toHaveBeenCalled();
-                    expect(createReadStream).not.toHaveBeenCalled();
+                    expect(createReadStreamSpy).not.toHaveBeenCalled();
                 });
             });
         });

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

@@ -31,7 +31,7 @@ describe(externalsPlugin.name, () => {
     const subject = () => externalsPlugin(context);
 
     test('returns plugin with correct name', () => {
-        expect(subject()!.name).toBe('externals');
+        expect(subject()!.name).toBe('st:externals');
     });
 
     test('enforces pre', () => {
@@ -70,12 +70,33 @@ describe(externalsPlugin.name, () => {
     describe('when build is production', () => {
         beforeEach(() => (context.build.isProduction = true));
 
+        describe('resolveId filter', () => {
+            const subject = () =>
+                (externalsPlugin(context) as { resolveId: { filter: unknown } }).resolveId.filter;
+
+            test('matches each dependency exactly', () => {
+                expect(subject()).toEqual({ id: [/^react$/, /^@scope\/lib$/] });
+            });
+
+            describe('when a dependency name contains regex characters', () => {
+                beforeEach(() =>
+                    jest.mocked(getExternals).mockReturnValue({ 'lodash.throttle': 'x' })
+                );
+
+                test('escapes them', () => {
+                    expect(subject()).toEqual({ id: [/^lodash\.throttle$/] });
+                });
+            });
+        });
+
         describe('resolveId', () => {
             let source: string;
 
             const subject = () => {
-                const plugin = externalsPlugin(context)!;
-                return (plugin.resolveId as Function).call(plugin, source);
+                const { resolveId } = externalsPlugin(context) as {
+                    resolveId: { handler: Function };
+                };
+                return resolveId.handler.call({}, source);
             };
 
             describe('with known dependency', () => {

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

@@ -28,7 +28,7 @@ describe(htmlPlugin.name, () => {
         jest.mocked(getSharedEntryPoints).mockReturnValue({ css: [], js: [] });
         context = {
             build: { name: 'my-app', isProduction: false },
-            package: { isWebComponent: false, source: 'src' },
+            package: { isWebComponent: false, source: 'src', destination: 'dist' },
             bundlerConfig: { pluginOverrides: {} },
         } as ViteBuildContext;
     });
@@ -38,7 +38,7 @@ describe(htmlPlugin.name, () => {
     const subject = () => htmlPlugin(context);
 
     test('returns plugin with correct name', () => {
-        expect(subject().name).toBe('html');
+        expect(subject().name).toBe('st:html');
     });
 
     test('constructs Eta with default template directory', () => {
@@ -170,6 +170,7 @@ describe(htmlPlugin.name, () => {
                     isProduction: context.build.isProduction,
                     isWebComponent: context.package.isWebComponent,
                     name: context.build.name,
+                    tsOutDir: context.package.destination,
                 });
             });
 
@@ -310,7 +311,7 @@ describe(htmlPlugin.name, () => {
 
         beforeEach(() => {
             req = { url: '/other' };
-            res = { end: jest.fn() };
+            res = { end: jest.fn(), setHeader: jest.fn() };
             next = jest.fn();
 
             const plugin = htmlPlugin(context);
@@ -350,6 +351,12 @@ describe(htmlPlugin.name, () => {
                 expect(res.end).toHaveBeenCalledWith(TRANSFORMED_HTML);
             });
 
+            test('sets HTML content type', async () => {
+                await subject();
+
+                expect(res.setHeader).toHaveBeenCalledWith('Content-Type', 'text/html');
+            });
+
             test('does not call next middleware', async () => {
                 await subject();
 

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

@@ -19,7 +19,7 @@ describe('Vite host HTML template', () => {
         jest.mocked(getSharedEntryPoints).mockReturnValue({ css, js });
         context = {
             build: { name: 'my-mfe', isProduction: true },
-            package: { isWebComponent: false, source: __dirname },
+            package: { isWebComponent: false, source: __dirname, destination: 'dist' },
             bundlerConfig: { pluginOverrides: {} },
         } as ViteBuildContext;
     });
@@ -70,13 +70,21 @@ describe('Vite host HTML template', () => {
     test('renders each shared JS script', () => {
         const html = subject();
 
-        js.forEach(item => expect(html).toContain(`<script src="./${item}"></script>`));
+        js.forEach(item => expect(html).toContain(`<script defer src="./${item}"></script>`));
     });
 
     test('imports the host entry module', () => {
         expect(subject()).toContain("import './dist/index'");
     });
 
+    describe('with a non-default tsconfig outDir', () => {
+        beforeEach(() => (context.package.destination = 'lib'));
+
+        test('imports the entry from that directory', () => {
+            expect(subject()).toContain(`import './${context.package.destination}/index'`);
+        });
+    });
+
     describe('when web component', () => {
         beforeEach(() => {
             context.package.isWebComponent = true;

package/src/vite/plugins/__tests__/ignore-modules-plugin.test.ts

@@ -5,7 +5,7 @@ jest.mock('../../../core', () => ({
     checkResource: jest.fn(),
 }));
 
-describe(ignoreModulesPlugin.name, () => {
+describe(`[startup] ${ignoreModulesPlugin.name}`, () => {
     const moduleName = 'some-module';
     const context = {} as BuildContext;
     const checker = jest.fn();
@@ -18,21 +18,32 @@ describe(ignoreModulesPlugin.name, () => {
     const subject = () => ignoreModulesPlugin(context);
 
     test('creates plugin with correct name', () => {
-        expect(subject().name).toBe('ignore-modules');
+        expect(subject().name).toBe('st:ignore-modules');
     });
 
     test('enforces pre order so it runs before built-in resolvers', () => {
         expect(subject().enforce).toBe('pre');
     });
 
+    describe('resolveId filter', () => {
+        const subject = () =>
+            (ignoreModulesPlugin(context) as { resolveId: { filter: unknown } }).resolveId.filter;
+
+        test('runs the hook only for bare specifiers', () => {
+            expect(subject()).toEqual({ id: /^[@a-z]/ });
+        });
+    });
+
     describe('resolveId', () => {
         let importer: string | undefined;
 
         beforeEach(() => (importer = '/importer.ts'));
 
         const subject = () => {
-            const plugin = ignoreModulesPlugin(context);
-            return (plugin.resolveId as Function).call(plugin, moduleName, importer);
+            const { resolveId } = ignoreModulesPlugin(context) as {
+                resolveId: { handler: Function };
+            };
+            return resolveId.handler.call({}, moduleName, importer);
         };
 
         const itReturnsUndefined = () => {
@@ -72,14 +83,27 @@ describe(ignoreModulesPlugin.name, () => {
         });
     });
 
+    describe('load filter', () => {
+        const subject = () =>
+            (ignoreModulesPlugin(context) as { load: { filter: { id: RegExp } } }).load.filter.id;
+
+        test('matches the plugin virtual module ids', () => {
+            expect(subject().test(`${THROW_PREFIX}${moduleName}`)).toBe(true);
+        });
+
+        test('ignores ordinary module ids', () => {
+            expect(subject().test('/src/app.tsx')).toBe(false);
+        });
+    });
+
     describe('load', () => {
         let id: string;
 
         beforeEach(() => (id = moduleName));
 
         const subject = () => {
-            const plugin = ignoreModulesPlugin(context);
-            return (plugin.load as Function).call(plugin, id);
+            const { load } = ignoreModulesPlugin(context) as { load: { handler: Function } };
+            return load.handler.call({}, id);
         };
 
         test('returns undefined', () => {

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

@@ -11,7 +11,12 @@ describe(istanbulPlugin.name, () => {
     beforeEach(() => {
         jest.clearAllMocks();
         jest.mocked(importEsm).mockResolvedValue({ default: mockIstanbul });
-        context = { options: {} } as ViteBuildContext;
+        context = {
+            options: {},
+            build: {},
+            package: { destination: 'dist' },
+            bundlerConfig: {},
+        } as ViteBuildContext;
     });
 
     const subject = () => istanbulPlugin(context);
@@ -58,5 +63,41 @@ describe(istanbulPlugin.name, () => {
                 expect.objectContaining({ exclude: ['**/node_modules/**', '**/.yalc/**'] })
             );
         });
+
+        describe('when the package exposes shared dependencies', () => {
+            beforeEach(() => {
+                context.package.isExposeSharedDependencies = true;
+            });
+
+            test('also excludes the shared dependencies', async () => {
+                await subject();
+
+                expect(mockIstanbul).toHaveBeenCalledWith(
+                    expect.objectContaining({
+                        exclude: [
+                            '**/node_modules/**',
+                            '**/.yalc/**',
+                            `${context.package.destination}/bundle/shared/**`,
+                        ],
+                    })
+                );
+            });
+
+            describe('when package has custom outDir', () => {
+                const outDir = 'foo';
+
+                beforeEach(() => (context.bundlerConfig.outDir = outDir));
+
+                test('excludes custom shared dependencies location', async () => {
+                    await subject();
+
+                    expect(mockIstanbul).toHaveBeenCalledWith(
+                        expect.objectContaining({
+                            exclude: ['**/node_modules/**', '**/.yalc/**', `${outDir}/shared/**`],
+                        })
+                    );
+                });
+            });
+        });
     });
 });