Prerender all routes nested in Set with prerender prop

__fixtures__/example-todo-main/web/src/Routes.js

@@ -8,13 +8,18 @@
 // 'src/pages/Admin/BooksPage/BooksPage.js' -> AdminBooksPage
 
 import { Router, Route } from '@redwoodjs/router'
+import SetLayout from 'src/layouts/SetLayout'
 
 const Routes = () => {
   return (
     <Router>
       <Route path="/" page={HomePage} name="home" prerender/>
       <Route path="/typescript" page={TypeScriptPage} name="typescriptPage" prerender />
       <Route path="/somewhereElse" page={EditUserPage} name="someOtherPage" prerender />
+      <Set wrap={SetLayout} prerender>
+        <Route path="/foo" page={FooPage} name="fooPage" />
+        <Route path="/bar" page={BarPage} name="barPage" />
+      </Set>
       <Route notfound page={NotFoundPage} />
     </Router>
   )

__fixtures__/example-todo-main/web/src/layouts/SetLayout/SetLayout.js

@@ -0,0 +1,6 @@
+export default ({ children }) => (
+  <>
+    <h1>Set Layout</h1>
+    <div>{children}</div>
+  </>
+)

__fixtures__/example-todo-main/web/src/pages/BarPage/BarPage.tsx

@@ -0,0 +1 @@
+export default () => "I'm the Bar page"

__fixtures__/example-todo-main/web/src/pages/FooPage/FooPage.tsx

@@ -0,0 +1 @@
+export default () => "I'm the Foo page"

packages/internal/src/__tests__/paths.test.ts

@@ -16,31 +16,51 @@ describe('paths', () => {
       )
 
       const pages = processPagesDir(pagesDir)
-      expect(pages[0].importName).toEqual('adminEditUserPage')
-      expect(pages[0].importPath).toEqual(
+
+      expect(pages.length).toEqual(7)
+
+      const adminEditUserPage = pages.find(page => page.importName === 'adminEditUserPage')
+      expect(adminEditUserPage).not.toBeUndefined()
+      expect(adminEditUserPage.importPath).toEqual(
         importStatementPath(
           path.join(pagesDir, 'admin/EditUserPage/EditUserPage')
         )
       )
-      expect(pages[1].importName).toEqual('FatalErrorPage')
-      expect(pages[1].importPath).toEqual(
-        importStatementPath(
-          path.join(pagesDir, 'FatalErrorPage/FatalErrorPage')
-        )
+
+      const barPage = pages.find(page => page.importName === 'BarPage')
+      expect(barPage).not.toBeUndefined()
+      expect(barPage.importPath).toEqual(
+        importStatementPath(path.join(pagesDir, 'BarPage/BarPage'))
+      )
+
+      const fatalErrorPage = pages.find(page => page.importName === 'FatalErrorPage')
+      expect(fatalErrorPage).not.toBeUndefined()
+      expect(fatalErrorPage.importPath).toEqual(
+        importStatementPath(path.join(pagesDir, 'FatalErrorPage/FatalErrorPage'))
       )
-      expect(pages[2].importName).toEqual('HomePage')
-      expect(pages[2].importPath).toEqual(
+
+      const fooPage = pages.find(page => page.importName === 'FooPage')
+      expect(fooPage).not.toBeUndefined()
+      expect(fooPage.importPath).toEqual(
+        importStatementPath(path.join(pagesDir, 'FooPage/FooPage'))
+      )
+
+      const homePage = pages.find(page => page.importName === 'HomePage')
+      expect(homePage).not.toBeUndefined()
+      expect(homePage.importPath).toEqual(
         importStatementPath(path.join(pagesDir, 'HomePage/HomePage'))
       )
-      expect(pages[3].importName).toEqual('NotFoundPage')
-      expect(pages[3].importPath).toEqual(
+
+      const notFoundPage = pages.find(page => page.importName === 'NotFoundPage')
+      expect(notFoundPage).not.toBeUndefined()
+      expect(notFoundPage.importPath).toEqual(
         importStatementPath(path.join(pagesDir, 'NotFoundPage/NotFoundPage'))
       )
-      expect(pages[4].importName).toEqual('TypeScriptPage')
-      expect(pages[4].importPath).toEqual(
-        importStatementPath(
-          path.join(pagesDir, 'TypeScriptPage/TypeScriptPage')
-        )
+
+      const typeScriptPage = pages.find(page => page.importName === 'TypeScriptPage')
+      expect(typeScriptPage).not.toBeUndefined()
+      expect(typeScriptPage.importPath).toEqual(
+        importStatementPath(path.join(pagesDir, 'TypeScriptPage/TypeScriptPage'))
       )
     })
   })

packages/router/src/Set.tsx

@@ -24,11 +24,11 @@ type SetProps<P> = P & {
    * the wrapped route they will be redirected to `unauthenticated` route.
    */
   private?: boolean
-  /**
-   * The page name where a user will be redirected when not authenticated
-   */
+  /** The page name where a user will be redirected when not authenticated */
   unauthenticated?: string
   role?: string | string[]
+  /** Prerender all pages in the set */
+  prerender?: boolean
   children: ReactNode
 }
 

packages/structure/src/model/RWRouter.ts

@@ -47,27 +47,48 @@ export class RWRouter extends FileNode {
   }
 
   /**
-   * the <Router> tag
+   * the `<Router>` tag
    */
-
   @lazy() private get jsxNode() {
     return this.sf
       .getDescendantsOfKind(tsm.SyntaxKind.JsxOpeningElement)
       .find((x) => x.getTagNameNode().getText() === 'Router')
   }
 
   /**
-   * One per <Route>
+   * One per `<Route>`
    */
-
   @lazy() get routes() {
     const self = this
+
     return iter(function* () {
       if (!self.jsxNode) {
         return
       }
       // TODO: make sure that they are nested within the <Router> tag
       // we are not checking it right now
+
+      const sets = self.sf
+        .getDescendantsOfKind(tsm.SyntaxKind.JsxElement)
+        .filter(
+          (x) => x.getOpeningElement().getTagNameNode().getText() === 'Set'
+        )
+
+      const prerenderSets = sets.filter((set) =>
+        set.getOpeningElement().getAttribute('prerender')
+      )
+
+      for (const set of prerenderSets) {
+        for (const x of set.getDescendantsOfKind(
+          tsm.SyntaxKind.JsxSelfClosingElement
+        )) {
+          const tagName = x.getTagNameNode().getText()
+          if (tagName === 'Route') {
+            x.insertAttribute(0, { name: 'prerender' })
+          }
+        }
+      }
+
       for (const x of self.sf.getDescendantsOfKind(
         tsm.SyntaxKind.JsxSelfClosingElement
       )) {
@@ -78,9 +99,11 @@ export class RWRouter extends FileNode {
       }
     })
   }
+
   @lazy() private get numNotFoundPages(): number {
     return this.routes.filter((r) => r.isNotFound).length
   }
+
   *ideInfo() {
     if (this.jsxNode) {
       let location = Location_fromNode(this.jsxNode)

packages/structure/src/model/__tests__/model.test.ts

@@ -17,6 +17,8 @@ describe('Redwood Project Model', () => {
         'NotFoundPage',
         'TypeScriptPage',
         'EditUserPage',
+        'FooPage',
+        'BarPage',
       ])
     )
     for (const page of project.pages) {
@@ -112,12 +114,11 @@ describe('Redwood Route detection', () => {
 
     const prerenderRoutes = routes
       .filter((r) => r.prerender)
-      // Make it a little easier to read
-      .map(({ name, path }) => {
-        return { name, path }
-      })
+      // Make it a little easier to read by only keeping the attributes we're
+      // interested in
+      .map(({ name, path }) => ({ name, path }))
 
-    expect(prerenderRoutes.length).toBe(3)
+    expect(prerenderRoutes.length).toBe(5)
     expect(prerenderRoutes).toContainEqual({ name: 'home', path: '/' })
     expect(prerenderRoutes).toContainEqual({
       name: 'typescriptPage',
@@ -127,6 +128,8 @@ describe('Redwood Route detection', () => {
       name: 'someOtherPage',
       path: '/somewhereElse',
     })
+    expect(prerenderRoutes).toContainEqual({ name: 'fooPage', path: '/foo' })
+    expect(prerenderRoutes).toContainEqual({ name: 'barPage', path: '/bar' })
   })
 })