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

Author: chargome

packages/nextjs/src/config/manifest/buildManifest.ts renamed to packages/nextjs/src/config/manifest/createRouteManifest.ts

@@ -1,17 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-
-export type RouteInfo = {
-  path: string;
-  dynamic: boolean;
-  pattern?: string;
-  paramNames?: string[];
-};
-
-export type RouteManifest = {
-  dynamic: RouteInfo[];
-  static: RouteInfo[];
-};
+import type { RouteInfo, RouteManifest } from './types';
 
 export type CreateRouteManifestOptions = {
   // For starters we only support app router
@@ -38,13 +27,12 @@ function getDynamicRouteSegment(name: string): string {
     // Required catchall: [...param]
     const paramName = name.slice(4, -1); // Remove [... and ]
     return `:${paramName}*`;
-  } else {
-    // Regular dynamic: [param]
-    return `:${name.slice(1, -1)}`;
   }
+  // Regular dynamic: [param]
+  return `:${name.slice(1, -1)}`;
 }
 
-function buildRegexForDynamicRoute(routePath: string): { pattern: string; paramNames: string[] } {
+function buildRegexForDynamicRoute(routePath: string): { regex: string; paramNames: string[] } {
   const segments = routePath.split('/').filter(Boolean);
   const regexSegments: string[] = [];
   const paramNames: string[] = [];
@@ -86,7 +74,7 @@ function buildRegexForDynamicRoute(routePath: string): { pattern: string; paramN
     pattern = `^/${regexSegments.join('/')}$`;
   }
 
-  return { pattern, paramNames };
+  return { regex: pattern, paramNames };
 }
 
 function scanAppDirectory(dir: string, basePath: string = ''): RouteInfo[] {
@@ -101,17 +89,15 @@ function scanAppDirectory(dir: string, basePath: string = ''): RouteInfo[] {
       const isDynamic = routePath.includes(':');
 
       if (isDynamic) {
-        const { pattern, paramNames } = buildRegexForDynamicRoute(routePath);
+        const { regex, paramNames } = buildRegexForDynamicRoute(routePath);
         routes.push({
           path: routePath,
-          dynamic: true,
-          pattern,
+          regex,
           paramNames,
         });
       } else {
         routes.push({
           path: routePath,
-          dynamic: false,
         });
       }
     }
@@ -171,8 +157,7 @@ export function createRouteManifest(options?: CreateRouteManifestOptions): Route
 
   if (!targetDir) {
     return {
-      dynamic: [],
-      static: [],
+      routes: [],
     };
   }
 
@@ -184,8 +169,7 @@ export function createRouteManifest(options?: CreateRouteManifestOptions): Route
   const routes = scanAppDirectory(targetDir);
 
   const manifest: RouteManifest = {
-    dynamic: routes.filter(route => route.dynamic),
-    static: routes.filter(route => !route.dynamic),
+    routes,
   };
 
   // set cache

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

@@ -0,0 +1,27 @@
+/**
+ * Information about a single route in the manifest
+ */
+export type RouteInfo = {
+  /**
+   * The parameterised route path, e.g. "/users/[id]"
+   */
+  path: string;
+  /**
+   * (Optional) The regex pattern for dynamic routes
+   */
+  regex?: string;
+  /**
+   * (Optional) The names of dynamic parameters in the route
+   */
+  paramNames?: string[];
+};
+
+/**
+ * The manifest containing all routes discovered in the app
+ */
+export type RouteManifest = {
+  /**
+   * List of all routes (static and dynamic)
+   */
+  routes: RouteInfo[];
+};

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

@@ -1,26 +1,26 @@
 import path from 'path';
 import { describe, expect, test } from 'vitest';
-import { createRouteManifest } from '../../../../../src/config/manifest/buildManifest';
+import { createRouteManifest } from '../../../../../src/config/manifest/createRouteManifest';
 
 describe('catchall', () => {
   const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
 
   test('should generate a manifest with catchall route', () => {
     expect(manifest).toEqual({
-      dynamic: [
+      routes: [
+        { path: '/' },
         {
           path: '/catchall/:path*?',
-          dynamic: true,
-          pattern: '^/catchall(?:/(.*))?$',
+          regex: '^/catchall(?:/(.*))?$',
           paramNames: ['path'],
         },
       ],
-      static: [{ path: '/', dynamic: false }],
     });
   });
 
   test('should generate correct pattern for catchall route', () => {
-    const regex = new RegExp(manifest.dynamic[0]?.pattern ?? '');
+    const catchallRoute = manifest.routes.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);
     expect(regex.test('/catchall/123/456')).toBe(true);

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

@@ -1,48 +1,42 @@
 import path from 'path';
 import { describe, expect, test } from 'vitest';
-import { createRouteManifest } from '../../../../../src/config/manifest/buildManifest';
+import { createRouteManifest } from '../../../../../src/config/manifest/createRouteManifest';
 
 describe('dynamic', () => {
   const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
 
-  test('should generate a comprehensive dynamic manifest', () => {
+  test('should generate a dynamic manifest', () => {
     expect(manifest).toEqual({
-      dynamic: [
+      routes: [
+        { path: '/' },
         {
           path: '/dynamic/:id',
-          dynamic: true,
-          pattern: '^/dynamic/([^/]+)$',
+          regex: '^/dynamic/([^/]+)$',
           paramNames: ['id'],
         },
+        { path: '/static/nested' },
         {
           path: '/users/:id',
-          dynamic: true,
-          pattern: '^/users/([^/]+)$',
+          regex: '^/users/([^/]+)$',
           paramNames: ['id'],
         },
         {
           path: '/users/:id/posts/:postId',
-          dynamic: true,
-          pattern: '^/users/([^/]+)/posts/([^/]+)$',
+          regex: '^/users/([^/]+)/posts/([^/]+)$',
           paramNames: ['id', 'postId'],
         },
         {
           path: '/users/:id/settings',
-          dynamic: true,
-          pattern: '^/users/([^/]+)/settings$',
+          regex: '^/users/([^/]+)/settings$',
           paramNames: ['id'],
         },
       ],
-      static: [
-        { path: '/', dynamic: false },
-        { path: '/static/nested', dynamic: false },
-      ],
     });
   });
 
   test('should generate correct pattern for single dynamic route', () => {
-    const singleDynamic = manifest.dynamic.find(route => route.path === '/dynamic/:id');
-    const regex = new RegExp(singleDynamic?.pattern ?? '');
+    const singleDynamic = manifest.routes.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);
     expect(regex.test('/dynamic/123/456')).toBe(false);
@@ -51,8 +45,8 @@ describe('dynamic', () => {
   });
 
   test('should generate correct pattern for mixed static-dynamic route', () => {
-    const mixedRoute = manifest.dynamic.find(route => route.path === '/users/:id/settings');
-    const regex = new RegExp(mixedRoute?.pattern ?? '');
+    const mixedRoute = manifest.routes.find(route => route.path === '/users/:id/settings');
+    const regex = new RegExp(mixedRoute?.regex ?? '');
 
     expect(regex.test('/users/123/settings')).toBe(true);
     expect(regex.test('/users/john-doe/settings')).toBe(true);
@@ -62,8 +56,8 @@ describe('dynamic', () => {
   });
 
   test('should generate correct pattern for multiple dynamic segments', () => {
-    const multiDynamic = manifest.dynamic.find(route => route.path === '/users/:id/posts/:postId');
-    const regex = new RegExp(multiDynamic?.pattern ?? '');
+    const multiDynamic = manifest.routes.find(route => route.path === '/users/:id/posts/:postId');
+    const regex = new RegExp(multiDynamic?.regex ?? '');
 
     expect(regex.test('/users/123/posts/456')).toBe(true);
     expect(regex.test('/users/john/posts/my-post')).toBe(true);
@@ -79,11 +73,11 @@ describe('dynamic', () => {
 
   test('should handle special characters in dynamic segments', () => {
     // Test that dynamic segments with special characters work properly
-    const userSettingsRoute = manifest.dynamic.find(route => route.path === '/users/:id/settings');
+    const userSettingsRoute = manifest.routes.find(route => route.path === '/users/:id/settings');
     expect(userSettingsRoute).toBeDefined();
-    expect(userSettingsRoute?.pattern).toBeDefined();
+    expect(userSettingsRoute?.regex).toBeDefined();
 
-    const regex = new RegExp(userSettingsRoute!.pattern!);
+    const regex = new RegExp(userSettingsRoute!.regex!);
     expect(regex.test('/users/user-with-dashes/settings')).toBe(true);
     expect(regex.test('/users/user_with_underscores/settings')).toBe(true);
     expect(regex.test('/users/123/settings')).toBe(true);

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

@@ -1,20 +1,19 @@
 import path from 'path';
 import { describe, expect, test } from 'vitest';
-import { createRouteManifest } from '../../../../../src/config/manifest/buildManifest';
+import { createRouteManifest } from '../../../../../src/config/manifest/createRouteManifest';
 
 describe('file-extensions', () => {
   const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
 
   test('should detect page files with all supported extensions', () => {
     expect(manifest).toEqual({
-      dynamic: [],
-      static: [
-        { path: '/', dynamic: false },
-        { path: '/javascript', dynamic: false },
-        { path: '/jsx-route', dynamic: false },
-        { path: '/mixed', dynamic: false },
-        { path: '/precedence', dynamic: false },
-        { path: '/typescript', dynamic: false },
+      routes: [
+        { path: '/' },
+        { path: '/javascript' },
+        { path: '/jsx-route' },
+        { path: '/mixed' },
+        { path: '/precedence' },
+        { path: '/typescript' },
       ],
     });
   });

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

@@ -1,34 +1,31 @@
 import path from 'path';
 import { describe, expect, test } from 'vitest';
-import { createRouteManifest } from '../../../../../src/config/manifest/buildManifest';
+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({
-      dynamic: [
+      routes: [
+        { path: '/' },
+        { path: '/login' },
+        { path: '/signup' },
+        { path: '/dashboard' },
         {
           path: '/dashboard/:id',
-          dynamic: true,
-          pattern: '^/dashboard/([^/]+)$',
+          regex: '^/dashboard/([^/]+)$',
           paramNames: ['id'],
         },
-      ],
-      static: [
-        { path: '/', dynamic: false },
-        { path: '/login', dynamic: false },
-        { path: '/signup', dynamic: false },
-        { path: '/dashboard', dynamic: false },
-        { path: '/settings/profile', dynamic: false },
-        { path: '/public/about', dynamic: false },
+        { path: '/settings/profile' },
+        { path: '/public/about' },
       ],
     });
   });
 
   test('should handle dynamic routes within route groups', () => {
-    const dynamicRoute = manifest.dynamic.find(route => route.path.includes('/dashboard/:id'));
-    const regex = new RegExp(dynamicRoute?.pattern ?? '');
+    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);

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

@@ -1,18 +1,12 @@
 import path from 'path';
 import { describe, expect, test } from 'vitest';
-import { createRouteManifest } from '../../../../../src/config/manifest/buildManifest';
+import { createRouteManifest } from '../../../../../src/config/manifest/createRouteManifest';
 
 describe('static', () => {
   test('should generate a static manifest', () => {
     const manifest = createRouteManifest({ appDirPath: path.join(__dirname, 'app') });
     expect(manifest).toEqual({
-      dynamic: [],
-      static: [
-        { path: '/', dynamic: false },
-        { path: '/some/nested', dynamic: false },
-        { path: '/user', dynamic: false },
-        { path: '/users', dynamic: false },
-      ],
+      routes: [{ path: '/' }, { path: '/some/nested' }, { path: '/user' }, { path: '/users' }],
     });
   });
 });