fix: use match instead and export fn for testing

Author: logaretm

packages/nextjs/src/config/withSentryConfig/getFinalConfigObjectUtils.ts

@@ -115,6 +115,16 @@ export function maybeCreateRouteManifest(
 
   // Apply route exclusion filter if configured
   const excludeFilter = userSentryOptions.routeManifestInjection?.exclude;
+  return filterRouteManifest(manifest, excludeFilter);
+}
+
+type ExcludeFilter = ((route: string) => boolean) | (string | RegExp)[] | undefined;
+
+/**
+ * Filters routes from the manifest based on the exclude filter.
+ * (Exported only for testing)
+ */
+export function filterRouteManifest(manifest: RouteManifest, excludeFilter: ExcludeFilter): RouteManifest {
   if (!excludeFilter) {
     return manifest;
   }
@@ -128,7 +138,8 @@ export function maybeCreateRouteManifest(
       if (typeof pattern === 'string') {
         return route === pattern;
       }
-      return pattern.test(route);
+
+      return !!route.match(pattern);
     });
   };
 

packages/nextjs/test/config/manifest/excludeRoutesFromManifest.test.ts

@@ -1,36 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { RouteManifest } from '../../../src/config/manifest/types';
-import type { SentryBuildOptions } from '../../../src/config/types';
-
-type RouteManifestInjectionOptions = Exclude<SentryBuildOptions['routeManifestInjection'], false | undefined>;
-type ExcludeFilter = RouteManifestInjectionOptions['exclude'];
-
-// Inline the filtering logic for unit testing
-// This mirrors what maybeCreateRouteManifest does internally
-function filterManifest(manifest: RouteManifest, excludeFilter: ExcludeFilter): RouteManifest {
-  if (!excludeFilter) {
-    return manifest;
-  }
-
-  const shouldExclude = (route: string): boolean => {
-    if (typeof excludeFilter === 'function') {
-      return excludeFilter(route);
-    }
-
-    return excludeFilter.some((pattern: string | RegExp) => {
-      if (typeof pattern === 'string') {
-        return route === pattern;
-      }
-      return pattern.test(route);
-    });
-  };
-
-  return {
-    staticRoutes: manifest.staticRoutes.filter(r => !shouldExclude(r.path)),
-    dynamicRoutes: manifest.dynamicRoutes.filter(r => !shouldExclude(r.path)),
-    isrRoutes: manifest.isrRoutes.filter(r => !shouldExclude(r)),
-  };
-}
+import { filterRouteManifest } from '../../../src/config/withSentryConfig/getFinalConfigObjectUtils';
 
 describe('routeManifestInjection.exclude', () => {
   const mockManifest: RouteManifest = {
@@ -52,14 +22,14 @@ describe('routeManifestInjection.exclude', () => {
 
   describe('with no filter', () => {
     it('should return manifest unchanged', () => {
-      const result = filterManifest(mockManifest, undefined);
+      const result = filterRouteManifest(mockManifest, undefined);
       expect(result).toEqual(mockManifest);
     });
   });
 
   describe('with string patterns', () => {
     it('should exclude exact string matches', () => {
-      const result = filterManifest(mockManifest, ['/admin']);
+      const result = filterRouteManifest(mockManifest, ['/admin']);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual([
         '/',
@@ -71,7 +41,7 @@ describe('routeManifestInjection.exclude', () => {
     });
 
     it('should exclude multiple exact matches', () => {
-      const result = filterManifest(mockManifest, ['/admin', '/about', '/blog']);
+      const result = filterRouteManifest(mockManifest, ['/admin', '/about', '/blog']);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual([
         '/',
@@ -85,22 +55,22 @@ describe('routeManifestInjection.exclude', () => {
 
   describe('with regex patterns', () => {
     it('should exclude routes matching regex', () => {
-      const result = filterManifest(mockManifest, [/^\/admin/]);
+      const result = filterRouteManifest(mockManifest, [/^\/admin/]);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/about', '/internal/secret', '/public/page']);
       expect(result.dynamicRoutes.map(r => r.path)).toEqual(['/users/:id', '/secret-feature/:id']);
       expect(result.isrRoutes).toEqual(['/blog', '/internal/stats']);
     });
 
     it('should support multiple regex patterns', () => {
-      const result = filterManifest(mockManifest, [/^\/admin/, /^\/internal/]);
+      const result = filterRouteManifest(mockManifest, [/^\/admin/, /^\/internal/]);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/about', '/public/page']);
       expect(result.isrRoutes).toEqual(['/blog']);
     });
 
     it('should support partial regex matches', () => {
-      const result = filterManifest(mockManifest, [/secret/]);
+      const result = filterRouteManifest(mockManifest, [/secret/]);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual([
         '/',
@@ -111,27 +81,45 @@ describe('routeManifestInjection.exclude', () => {
       ]);
       expect(result.dynamicRoutes.map(r => r.path)).toEqual(['/users/:id', '/admin/users/:id']);
     });
+
+    it('should handle regex with global flag consistently across multiple routes', () => {
+      // Regex with `g` flag has stateful lastIndex - ensure it works correctly
+      const globalRegex = /admin/g;
+      const result = filterRouteManifest(mockManifest, [globalRegex]);
+
+      // All admin routes should be excluded, not just every other one
+      expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/about', '/internal/secret', '/public/page']);
+      expect(result.dynamicRoutes.map(r => r.path)).toEqual(['/users/:id', '/secret-feature/:id']);
+      expect(result.isrRoutes).toEqual(['/blog', '/internal/stats']);
+    });
+
+    it('should handle regex with global and case-insensitive flags', () => {
+      const result = filterRouteManifest(mockManifest, [/ADMIN/gi]);
+
+      expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/about', '/internal/secret', '/public/page']);
+      expect(result.dynamicRoutes.map(r => r.path)).toEqual(['/users/:id', '/secret-feature/:id']);
+    });
   });
 
   describe('with mixed patterns', () => {
     it('should support both strings and regex', () => {
-      const result = filterManifest(mockManifest, ['/about', /^\/admin/]);
+      const result = filterRouteManifest(mockManifest, ['/about', /^\/admin/]);
 
       expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/internal/secret', '/public/page']);
     });
   });
 
   describe('with function filter', () => {
     it('should exclude routes where function returns true', () => {
-      const result = filterManifest(mockManifest, (route: string) => route.includes('admin'));
+      const result = filterRouteManifest(mockManifest, (route: string) => route.includes('admin'));
 
       expect(result.staticRoutes.map(r => r.path)).toEqual(['/', '/about', '/internal/secret', '/public/page']);
       expect(result.dynamicRoutes.map(r => r.path)).toEqual(['/users/:id', '/secret-feature/:id']);
       expect(result.isrRoutes).toEqual(['/blog', '/internal/stats']);
     });
 
     it('should support complex filter logic', () => {
-      const result = filterManifest(mockManifest, (route: string) => {
+      const result = filterRouteManifest(mockManifest, (route: string) => {
         // Exclude anything with "secret" or "internal" or admin routes
         return route.includes('secret') || route.includes('internal') || route.startsWith('/admin');
       });
@@ -150,25 +138,25 @@ describe('routeManifestInjection.exclude', () => {
         isrRoutes: [],
       };
 
-      const result = filterManifest(emptyManifest, [/admin/]);
+      const result = filterRouteManifest(emptyManifest, [/admin/]);
       expect(result).toEqual(emptyManifest);
     });
 
     it('should handle filter that excludes everything', () => {
-      const result = filterManifest(mockManifest, () => true);
+      const result = filterRouteManifest(mockManifest, () => true);
 
       expect(result.staticRoutes).toEqual([]);
       expect(result.dynamicRoutes).toEqual([]);
       expect(result.isrRoutes).toEqual([]);
     });
 
     it('should handle filter that excludes nothing', () => {
-      const result = filterManifest(mockManifest, () => false);
+      const result = filterRouteManifest(mockManifest, () => false);
       expect(result).toEqual(mockManifest);
     });
 
     it('should handle empty filter array', () => {
-      const result = filterManifest(mockManifest, []);
+      const result = filterRouteManifest(mockManifest, []);
       expect(result).toEqual(mockManifest);
     });
   });