@servicetitan/startup 37.0.1 → 38.0.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 },
@@ -42,89 +43,91 @@ describe(devServerRoutingPlugin.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('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__/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/**`],
+                        })
+                    );
+                });
+            });
+        });
     });
 });

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

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import type { Plugin } from 'vite';
+import { normalizePath, type Plugin } from 'vite';
 import { getBundleType, type BuildContext } from '../../core';
 import { log } from '../../utils';
 
@@ -45,7 +45,7 @@ export function devServerRoutingPlugin(context: BuildContext): Plugin {
         },
 
         configureServer(server) {
-            const outDirRelative = `/${path.relative(process.cwd(), outDir)}/`;
+            const outDirRelative = `/${normalizePath(path.relative(process.cwd(), outDir))}/`;
 
             server.middlewares.use((req, _res, next) => {
                 logRequest(req);
@@ -72,7 +72,7 @@ export function devServerRoutingPlugin(context: BuildContext): Plugin {
             }
 
             const destDir = path.resolve(destination);
-            const mountPath = '/' + path.relative(process.cwd(), destDir);
+            const mountPath = '/' + normalizePath(path.relative(process.cwd(), destDir));
 
             const contentTypes: Record<string, string> = {
                 '.js': 'application/javascript',

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

@@ -1,4 +1,6 @@
+import path from 'path';
 import type { Plugin } from 'vite';
+import { resolveOutputPath } from '../../core';
 import { ViteBuildContext } from '../types';
 import { importEsm } from './utils';
 
@@ -11,9 +13,34 @@ export function istanbulPlugin(context: ViteBuildContext): Promise<Plugin> | und
     return importEsm<typeof import('vite-plugin-istanbul')>('vite-plugin-istanbul').then(
         ({ default: istanbul }) =>
             istanbul({
-                exclude: ['**/node_modules/**', '**/.yalc/**'],
+                exclude: [
+                    '**/node_modules/**',
+                    '**/.yalc/**',
+                    ...sharedDependenciesExclude(context),
+                ],
                 requireEnv: false,
                 forceBuildInstrument: true,
             })
     );
 }
+
+/*
+ * devServerRoutingPlugin serves the prebuilt shared-dependencies bundle (react, mobx, the
+ * design system, etc.) straight from disk at dev time. Instrumenting that vendor code breaks
+ * Vite's import analysis on the huge instrumented output and provides no useful coverage.
+ *
+ * vite-plugin-istanbul matches exclude patterns against paths relative to process.cwd()
+ * (via test-exclude's default `relativePath` behavior), so the pattern must be cwd-relative
+ * rather than absolute.
+ */
+function sharedDependenciesExclude(context: ViteBuildContext): string[] {
+    if (!context.package.isExposeSharedDependencies) {
+        return [];
+    }
+    const sharedContext = {
+        ...context,
+        build: { ...context.build, emitExposedDependencies: true },
+    };
+    const outputPath = resolveOutputPath(sharedContext, context.bundlerConfig.outDir);
+    return [path.join(path.relative(process.cwd(), outputPath), '**').replace(/\\/g, '/')];
+}

package/src/vite/types.ts

@@ -2,5 +2,8 @@ import { BuildContext } from '../core';
 import { ViteBundlerConfig } from '../utils';
 
 export type ViteBuildContext = BuildContext<
-    Required<Omit<ViteBundlerConfig, 'port'>> & Pick<ViteBundlerConfig, 'port'>
+    (Required<Omit<ViteBundlerConfig, 'port'>> & Pick<ViteBundlerConfig, 'port'>) & {
+        /** The resolved `build.outDir` override, if the package configures one. */
+        outDir?: string;
+    }
 >;