Merge branch 'cg-next-manifest-webpack' into cg-next-manifest-turbopack

Author: chargome

packages/nextjs/src/config/manifest/createRouteManifest.ts

@@ -5,10 +5,16 @@ import type { RouteInfo, RouteManifest } from './types';
 export type CreateRouteManifestOptions = {
   // For starters we only support app router
   appDirPath?: string;
+  /**
+   * Whether to include route groups (e.g., (auth-layout)) in the final route paths.
+   * By default, route groups are stripped from paths following Next.js convention.
+   */
+  includeRouteGroups?: boolean;
 };
 
 let manifestCache: RouteManifest | null = null;
 let lastAppDirPath: string | null = null;
+let lastIncludeRouteGroups: boolean | undefined = undefined;
 
 function isPageFile(filename: string): boolean {
   return filename === 'page.tsx' || filename === 'page.jsx' || filename === 'page.ts' || filename === 'page.js';
@@ -18,6 +24,11 @@ function isRouteGroup(name: string): boolean {
   return name.startsWith('(') && name.endsWith(')');
 }
 
+function normalizeRoutePath(routePath: string): string {
+  // Remove route group segments from the path
+  return routePath.replace(/\/\([^)]+\)/g, '');
+}
+
 function getDynamicRouteSegment(name: string): string {
   if (name.startsWith('[[...') && name.endsWith(']]')) {
     // Optional catchall: [[...param]]
@@ -59,7 +70,7 @@ function buildRegexForDynamicRoute(routePath: string): { regex: string; paramNam
         regexSegments.push('([^/]+)');
       }
     } else {
-      // Static segment
+      // Static segment - escape regex special characters including route group parentheses
       regexSegments.push(segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
     }
   }
@@ -77,26 +88,32 @@ function buildRegexForDynamicRoute(routePath: string): { regex: string; paramNam
   return { regex: pattern, paramNames };
 }
 
-function scanAppDirectory(dir: string, basePath: string = ''): RouteInfo[] {
-  const routes: RouteInfo[] = [];
+function scanAppDirectory(
+  dir: string,
+  basePath: string = '',
+  includeRouteGroups: boolean = false,
+): { dynamicRoutes: RouteInfo[]; staticRoutes: RouteInfo[] } {
+  const dynamicRoutes: RouteInfo[] = [];
+  const staticRoutes: RouteInfo[] = [];
 
   try {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     const pageFile = entries.some(entry => isPageFile(entry.name));
 
     if (pageFile) {
-      const routePath = basePath || '/';
+      // Conditionally normalize the path based on includeRouteGroups option
+      const routePath = includeRouteGroups ? basePath || '/' : normalizeRoutePath(basePath || '/');
       const isDynamic = routePath.includes(':');
 
       if (isDynamic) {
         const { regex, paramNames } = buildRegexForDynamicRoute(routePath);
-        routes.push({
+        dynamicRoutes.push({
           path: routePath,
           regex,
           paramNames,
         });
       } else {
-        routes.push({
+        staticRoutes.push({
           path: routePath,
         });
       }
@@ -105,34 +122,36 @@ function scanAppDirectory(dir: string, basePath: string = ''): RouteInfo[] {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const fullPath = path.join(dir, entry.name);
-
-        if (isRouteGroup(entry.name)) {
-          // Route groups don't affect the URL, just scan them
-          const subRoutes = scanAppDirectory(fullPath, basePath);
-          routes.push(...subRoutes);
-          continue;
-        }
-
-        const isDynamic = entry.name.startsWith('[') && entry.name.endsWith(']');
         let routeSegment: string;
 
-        if (isDynamic) {
+        const isDynamic = entry.name.startsWith('[') && entry.name.endsWith(']');
+        const isRouteGroupDir = isRouteGroup(entry.name);
+
+        if (isRouteGroupDir) {
+          if (includeRouteGroups) {
+            routeSegment = entry.name;
+          } else {
+            routeSegment = '';
+          }
+        } else if (isDynamic) {
           routeSegment = getDynamicRouteSegment(entry.name);
         } else {
           routeSegment = entry.name;
         }
 
-        const newBasePath = `${basePath}/${routeSegment}`;
-        const subRoutes = scanAppDirectory(fullPath, newBasePath);
-        routes.push(...subRoutes);
+        const newBasePath = routeSegment ? `${basePath}/${routeSegment}` : basePath;
+        const subRoutes = scanAppDirectory(fullPath, newBasePath, includeRouteGroups);
+
+        dynamicRoutes.push(...subRoutes.dynamicRoutes);
+        staticRoutes.push(...subRoutes.staticRoutes);
       }
     }
   } catch (error) {
     // eslint-disable-next-line no-console
     console.warn('Error building route manifest:', error);
   }
 
-  return routes;
+  return { dynamicRoutes, staticRoutes };
 }
 
 /**
@@ -157,24 +176,27 @@ export function createRouteManifest(options?: CreateRouteManifestOptions): Route
 
   if (!targetDir) {
     return {
-      routes: [],
+      dynamicRoutes: [],
+      staticRoutes: [],
     };
   }
 
   // Check if we can use cached version
-  if (manifestCache && lastAppDirPath === targetDir) {
+  if (manifestCache && lastAppDirPath === targetDir && lastIncludeRouteGroups === options?.includeRouteGroups) {
     return manifestCache;
   }
 
-  const routes = scanAppDirectory(targetDir);
+  const { dynamicRoutes, staticRoutes } = scanAppDirectory(targetDir, '', options?.includeRouteGroups);
 
   const manifest: RouteManifest = {
-    routes,
+    dynamicRoutes,
+    staticRoutes,
   };
 
   // set cache
   manifestCache = manifest;
   lastAppDirPath = targetDir;
+  lastIncludeRouteGroups = options?.includeRouteGroups;
 
   return manifest;
 }

packages/nextjs/src/config/manifest/types.ts

@@ -21,7 +21,12 @@ export type RouteInfo = {
  */
 export type RouteManifest = {
   /**
-   * List of all routes (static and dynamic)
+   * List of all dynamic routes
    */
-  routes: RouteInfo[];
+  dynamicRoutes: RouteInfo[];
+
+  /**
+   * List of all static routes
+   */
+  staticRoutes: RouteInfo[];
 };

packages/nextjs/test/config/manifest/suites/catchall/catchall.test.ts

@@ -7,8 +7,8 @@ describe('catchall', () => {
 
   test('should generate a manifest with catchall route', () => {
     expect(manifest).toEqual({
-      routes: [
-        { path: '/' },
+      staticRoutes: [{ path: '/' }],
+      dynamicRoutes: [
         {
           path: '/catchall/:path*?',
           regex: '^/catchall(?:/(.*))?$',
@@ -19,7 +19,7 @@ describe('catchall', () => {
   });
 
   test('should generate correct pattern for catchall route', () => {
-    const catchallRoute = manifest.routes.find(route => route.path === '/catchall/:path*?');
+    const catchallRoute = manifest.dynamicRoutes.find(route => route.path === '/catchall/:path*?');
     const regex = new RegExp(catchallRoute?.regex ?? '');
     expect(regex.test('/catchall/123')).toBe(true);
     expect(regex.test('/catchall/abc')).toBe(true);

packages/nextjs/test/config/manifest/suites/dynamic/app/dynamic/static/page.tsx

@@ -0,0 +1 @@
+// Static

packages/nextjs/test/config/manifest/suites/dynamic/dynamic.test.ts

@@ -7,14 +7,13 @@ describe('dynamic', () => {
 
   test('should generate a dynamic manifest', () => {
     expect(manifest).toEqual({
-      routes: [
-        { path: '/' },
+      staticRoutes: [{ path: '/' }, { path: '/dynamic/static' }, { path: '/static/nested' }],
+      dynamicRoutes: [
         {
           path: '/dynamic/:id',
           regex: '^/dynamic/([^/]+)$',
           paramNames: ['id'],
         },
-        { path: '/static/nested' },
         {
           path: '/users/:id',
           regex: '^/users/([^/]+)$',
@@ -35,7 +34,7 @@ describe('dynamic', () => {
   });
 
   test('should generate correct pattern for single dynamic route', () => {
-    const singleDynamic = manifest.routes.find(route => route.path === '/dynamic/:id');
+    const singleDynamic = manifest.dynamicRoutes.find(route => route.path === '/dynamic/:id');
     const regex = new RegExp(singleDynamic?.regex ?? '');
     expect(regex.test('/dynamic/123')).toBe(true);
     expect(regex.test('/dynamic/abc')).toBe(true);
@@ -45,7 +44,7 @@ describe('dynamic', () => {
   });
 
   test('should generate correct pattern for mixed static-dynamic route', () => {
-    const mixedRoute = manifest.routes.find(route => route.path === '/users/:id/settings');
+    const mixedRoute = manifest.dynamicRoutes.find(route => route.path === '/users/:id/settings');
     const regex = new RegExp(mixedRoute?.regex ?? '');
 
     expect(regex.test('/users/123/settings')).toBe(true);
@@ -56,7 +55,7 @@ describe('dynamic', () => {
   });
 
   test('should generate correct pattern for multiple dynamic segments', () => {
-    const multiDynamic = manifest.routes.find(route => route.path === '/users/:id/posts/:postId');
+    const multiDynamic = manifest.dynamicRoutes.find(route => route.path === '/users/:id/posts/:postId');
     const regex = new RegExp(multiDynamic?.regex ?? '');
 
     expect(regex.test('/users/123/posts/456')).toBe(true);
@@ -72,8 +71,7 @@ describe('dynamic', () => {
   });
 
   test('should handle special characters in dynamic segments', () => {
-    // Test that dynamic segments with special characters work properly
-    const userSettingsRoute = manifest.routes.find(route => route.path === '/users/:id/settings');
+    const userSettingsRoute = manifest.dynamicRoutes.find(route => route.path === '/users/:id/settings');
     expect(userSettingsRoute).toBeDefined();
     expect(userSettingsRoute?.regex).toBeDefined();
 

packages/nextjs/test/config/manifest/suites/file-extensions/file-extensions.test.ts

@@ -7,14 +7,15 @@ describe('file-extensions', () => {
 
   test('should detect page files with all supported extensions', () => {
     expect(manifest).toEqual({
-      routes: [
+      staticRoutes: [
         { path: '/' },
         { path: '/javascript' },
         { path: '/jsx-route' },
         { path: '/mixed' },
         { path: '/precedence' },
         { path: '/typescript' },
       ],
+      dynamicRoutes: [],
     });
   });
 });

packages/nextjs/test/config/manifest/suites/route-groups/route-groups.test.ts

@@ -3,31 +3,90 @@ import { describe, expect, test } from 'vitest';
 import { createRouteManifest } from '../../../../../src/config/manifest/createRouteManifest';
 
 describe('route-groups', () => {
-  const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
-
-  test('should generate a manifest with route groups', () => {
-    expect(manifest).toEqual({
-      routes: [
-        { path: '/' },
-        { path: '/login' },
-        { path: '/signup' },
-        { path: '/dashboard' },
-        {
-          path: '/dashboard/:id',
-          regex: '^/dashboard/([^/]+)$',
-          paramNames: ['id'],
-        },
-        { path: '/settings/profile' },
-        { path: '/public/about' },
-      ],
+  const appDirPath = path.join(__dirname, 'app');
+
+  describe('default behavior (route groups stripped)', () => {
+    const manifest = createRouteManifest({ appDirPath });
+
+    test('should generate a manifest with route groups stripped', () => {
+      expect(manifest).toEqual({
+        staticRoutes: [
+          { path: '/' },
+          { path: '/login' },
+          { path: '/signup' },
+          { path: '/dashboard' },
+          { path: '/settings/profile' },
+          { path: '/public/about' },
+        ],
+        dynamicRoutes: [
+          {
+            path: '/dashboard/:id',
+            regex: '^/dashboard/([^/]+)$',
+            paramNames: ['id'],
+          },
+        ],
+      });
+    });
+
+    test('should handle dynamic routes within route groups', () => {
+      const dynamicRoute = manifest.dynamicRoutes.find(route => route.path.includes('/dashboard/:id'));
+      const regex = new RegExp(dynamicRoute?.regex ?? '');
+      expect(regex.test('/dashboard/123')).toBe(true);
+      expect(regex.test('/dashboard/abc')).toBe(true);
+      expect(regex.test('/dashboard/123/456')).toBe(false);
     });
   });
 
-  test('should handle dynamic routes within route groups', () => {
-    const dynamicRoute = manifest.routes.find(route => route.path.includes('/dashboard/:id'));
-    const regex = new RegExp(dynamicRoute?.regex ?? '');
-    expect(regex.test('/dashboard/123')).toBe(true);
-    expect(regex.test('/dashboard/abc')).toBe(true);
-    expect(regex.test('/dashboard/123/456')).toBe(false);
+  describe('includeRouteGroups: true', () => {
+    const manifest = createRouteManifest({ appDirPath, includeRouteGroups: true });
+
+    test('should generate a manifest with route groups included', () => {
+      expect(manifest).toEqual({
+        staticRoutes: [
+          { path: '/' },
+          { path: '/(auth)/login' },
+          { path: '/(auth)/signup' },
+          { path: '/(dashboard)/dashboard' },
+          { path: '/(dashboard)/settings/profile' },
+          { path: '/(marketing)/public/about' },
+        ],
+        dynamicRoutes: [
+          {
+            path: '/(dashboard)/dashboard/:id',
+            regex: '^/\\(dashboard\\)/dashboard/([^/]+)$',
+            paramNames: ['id'],
+          },
+        ],
+      });
+    });
+
+    test('should handle dynamic routes within route groups with proper regex escaping', () => {
+      const dynamicRoute = manifest.dynamicRoutes.find(route => route.path.includes('/(dashboard)/dashboard/:id'));
+      const regex = new RegExp(dynamicRoute?.regex ?? '');
+      expect(regex.test('/(dashboard)/dashboard/123')).toBe(true);
+      expect(regex.test('/(dashboard)/dashboard/abc')).toBe(true);
+      expect(regex.test('/(dashboard)/dashboard/123/456')).toBe(false);
+      expect(regex.test('/dashboard/123')).toBe(false); // Should not match without route group
+    });
+
+    test('should properly extract parameter names from dynamic routes with route groups', () => {
+      const dynamicRoute = manifest.dynamicRoutes.find(route => route.path.includes('/(dashboard)/dashboard/:id'));
+      expect(dynamicRoute?.paramNames).toEqual(['id']);
+    });
+
+    test('should handle nested static routes within route groups', () => {
+      const nestedStaticRoute = manifest.staticRoutes.find(route => route.path === '/(dashboard)/settings/profile');
+      expect(nestedStaticRoute).toBeDefined();
+    });
+
+    test('should handle multiple route groups correctly', () => {
+      const authLogin = manifest.staticRoutes.find(route => route.path === '/(auth)/login');
+      const authSignup = manifest.staticRoutes.find(route => route.path === '/(auth)/signup');
+      const marketingPublic = manifest.staticRoutes.find(route => route.path === '/(marketing)/public/about');
+
+      expect(authLogin).toBeDefined();
+      expect(authSignup).toBeDefined();
+      expect(marketingPublic).toBeDefined();
+    });
   });
 });

packages/nextjs/test/config/manifest/suites/static/static.test.ts

@@ -6,7 +6,8 @@ describe('static', () => {
   test('should generate a static manifest', () => {
     const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
     expect(manifest).toEqual({
-      routes: [{ path: '/' }, { path: '/some/nested' }, { path: '/user' }, { path: '/users' }],
+      staticRoutes: [{ path: '/' }, { path: '/some/nested' }, { path: '/user' }, { path: '/users' }],
+      dynamicRoutes: [],
     });
   });
 });