feat(builders): routesFile option for prerender builder

Closes #1395

Author: wagnermaciel

modules/builders/src/prerender/index.spec.ts

@@ -28,15 +28,23 @@ describe('Prerender Builder', () => {
     await host.restore().toPromise();
   });
 
-  it('fails with error when no routes are provided', async () => {
+  it('fails with error when .routes nor .routesFile are defined', async () => {
     const run = await architect.scheduleTarget(target);
     await expectAsync(run.result)
       .toBeRejectedWith(
-        jasmine.objectContaining({ message: jasmine.stringMatching(`Data path "" should have required property 'routes'.`) })
+        jasmine.objectContaining({ message: jasmine.stringMatching(/Data path "" should match some schema in anyOf./) })
       );
     await run.stop();
   });
 
+  it('fails with error when no routes are provided', async () => {
+    const run = await architect.scheduleTarget(target, { routes: [] });
+    await expectAsync(run.result).toBeRejectedWith(
+      jasmine.objectContaining({ message: jasmine.stringMatching(/No routes found/)})
+    );
+    await run.stop();
+  });
+
   it('should generate output for route when provided', async () => {
     const run = await architect.scheduleTarget(target, { routes: ['foo'] });
     const output = await run.result;
@@ -73,4 +81,50 @@ describe('Prerender Builder', () => {
     expect(content).toContain('<router-outlet');
     await run.stop();
   });
+
+  it('should generate output for routes when provided with a file', async () => {
+    await host.write(
+      join(host.root(), 'routes-file.txt'),
+      virtualFs.stringToFileBuffer(
+        ['/foo', '/foo/bar'].join('\n')
+      ),
+    ).toPromise();
+    const run = await architect.scheduleTarget(target, {
+      routes: ['/foo', '/'],
+      routesFile: './routes-file.txt',
+    });
+    const output = await run.result;
+    expect(output.success).toBe(true);
+
+    const fooContent = virtualFs.fileBufferToString(
+      host.scopedSync().read(join(outputPathBrowser, 'foo/index.html'))
+    );
+    const fooBarContent = virtualFs.fileBufferToString(
+      host.scopedSync().read(join(outputPathBrowser, 'foo/bar/index.html'))
+    );
+    const appContent = virtualFs.fileBufferToString(
+      host.scopedSync().read(join(outputPathBrowser, 'index.html'))
+    );
+
+    expect(appContent).toContain('app app is running!');
+    expect(appContent).toContain('This page was prerendered with Angular Universal');
+
+    expect(fooContent).toContain('foo works!');
+    expect(fooContent).toContain('This page was prerendered with Angular Universal');
+
+    expect(fooBarContent).toContain('foo-bar works!');
+    expect(fooBarContent).toContain('This page was prerendered with Angular Universal');
+
+    await run.stop();
+  });
+
+  it('should halt execution if a route file is given but does not exist.', async () => {
+    const run = await architect.scheduleTarget(target, {
+      routesFile: './nonexistent-file.txt',
+    });
+    await expectAsync(run.result).toBeRejectedWith(
+      jasmine.objectContaining({ message: jasmine.stringMatching(/no such file or directory/)})
+    );
+    await run.stop();
+  });
 });

modules/builders/src/prerender/index.ts

@@ -13,25 +13,70 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 import { Schema } from './schema';
+import { getRoutes } from './utils';
 
 export type PrerenderBuilderOptions = Schema & json.JsonObject;
 
-export type PrerenderBuilderOutput = BuilderOutput & {
+export type PrerenderBuilderOutput = BuilderOutput;
+
+type BuildBuilderOutput = BuilderOutput & {
   baseOutputPath: string;
   outputPaths: string[];
   outputPath: string;
 };
 
+type ScheduleBuildsOutput = BuilderOutput & {
+  serverResult?: BuildBuilderOutput;
+  browserResult?: BuildBuilderOutput;
+};
+
+/**
+ * Schedules the server and browser builds and returns their results if both builds are successful.
+ */
+async function _scheduleBuilds(
+  options: PrerenderBuilderOptions,
+  context: BuilderContext
+): Promise<ScheduleBuildsOutput> {
+  const browserTarget = targetFromTargetString(options.browserTarget);
+  const serverTarget = targetFromTargetString(options.serverTarget);
+
+  const browserTargetRun = await context.scheduleTarget(browserTarget, {
+    watch: false,
+    serviceWorker: false,
+    // todo: handle service worker augmentation
+  });
+  const serverTargetRun = await context.scheduleTarget(serverTarget, {
+    watch: false,
+  });
+
+  try {
+    const [browserResult, serverResult] = await Promise.all([
+      browserTargetRun.result as unknown as BuildBuilderOutput,
+      serverTargetRun.result as unknown as BuildBuilderOutput,
+    ]);
+
+    const success =
+      browserResult.success && serverResult.success && browserResult.baseOutputPath !== undefined;
+    const error = browserResult.error || serverResult.error as string;
+
+    return { success, error, browserResult, serverResult };
+  } catch (e) {
+    return { success: false, error: e.message };
+  } finally {
+    await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);
+  }
+}
+
 /**
  * Renders each route in options.routes and writes them to
  * <route>/index.html for each output path in the browser result.
  */
 async function _renderUniversal(
-  options: Schema,
+  routes: string[],
   context: BuilderContext,
-  browserResult: PrerenderBuilderOutput,
-  serverResult: PrerenderBuilderOutput,
-): Promise<PrerenderBuilderOutput> {
+  browserResult: BuildBuilderOutput,
+  serverResult: BuildBuilderOutput,
+): Promise<BuildBuilderOutput> {
   // We need to render the routes for each locale from the browser output.
   for (const outputPath of browserResult.outputPaths) {
     const localeDirectory = path.relative(browserResult.baseOutputPath, outputPath);
@@ -40,10 +85,10 @@ async function _renderUniversal(
     const { AppServerModuleDef, renderModuleFn } =
       await _getServerModuleBundle(serverResult, localeDirectory);
 
-    context.logger.info(`\nPrerendering ${options.routes.length} route(s) to ${outputPath}`);
+    context.logger.info(`\nPrerendering ${routes.length} route(s) to ${outputPath}`);
 
     // Render each route and write them to <route>/index.html.
-    for (const route of options.routes) {
+    for (const route of routes) {
       const renderOpts = {
         document: indexHtml + '<!-- This page was prerendered with Angular Universal -->',
         url: route,
@@ -59,8 +104,6 @@ async function _renderUniversal(
         fs.writeFileSync(browserIndexOutputPathOriginal, indexHtml);
       }
 
-      // There will never conflicting output folders
-      // because items in options.routes must be unique.
       try {
         fs.mkdirSync(outputFolderPath, { recursive: true });
         fs.writeFileSync(outputIndexPath, html);
@@ -84,7 +127,7 @@ async function _renderUniversal(
  * Throws if no app module bundle is found.
  */
 async function _getServerModuleBundle(
-  serverResult: PrerenderBuilderOutput,
+  serverResult: BuildBuilderOutput,
   browserLocaleDirectory: string,
 ) {
   const { baseOutputPath = '' } = serverResult;
@@ -127,38 +170,18 @@ async function _getServerModuleBundle(
 export async function execute(
   options: PrerenderBuilderOptions,
   context: BuilderContext
-): Promise<PrerenderBuilderOutput | BuilderOutput> {
-  const browserTarget = targetFromTargetString(options.browserTarget);
-  const serverTarget = targetFromTargetString(options.serverTarget);
-
-  const browserTargetRun = await context.scheduleTarget(browserTarget, {
-    watch: false,
-    serviceWorker: false,
-    // todo: handle service worker augmentation
-  });
-  const serverTargetRun = await context.scheduleTarget(serverTarget, {
-    watch: false,
-  });
-
-  try {
-    const [browserResult, serverResult] = await Promise.all([
-      browserTargetRun.result as unknown as PrerenderBuilderOutput,
-      serverTargetRun.result as unknown as PrerenderBuilderOutput,
-    ]);
-
-    if (browserResult.success === false || browserResult.baseOutputPath === undefined) {
-      return browserResult;
-    }
-    if (serverResult.success === false) {
-      return serverResult;
-    }
-
-    return await _renderUniversal(options, context, browserResult, serverResult);
-  } catch (e) {
-    return { success: false, error: e.message };
-  } finally {
-    await Promise.all([browserTargetRun.stop(), serverTargetRun.stop()]);
+): Promise<PrerenderBuilderOutput> {
+  const routes = getRoutes(context.workspaceRoot, options.routesFile, options.routes);
+  if (!routes.length) {
+    throw new Error('No routes found.');
+  }
+  const result = await _scheduleBuilds(options, context);
+  const { success, error, browserResult, serverResult } = result;
+  if (!success || !browserResult || !serverResult) {
+    return { success, error } as BuilderOutput;
   }
+
+  return _renderUniversal(routes, context, browserResult, serverResult);
 }
 
 export default createBuilder(execute);

modules/builders/src/prerender/schema.json

@@ -13,6 +13,10 @@
       "description": "Server target to use for prerendering the app.",
       "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
     },
+    "routesFile": {
+      "type": "string",
+      "description": "The path to a file containing routes separated by newlines."
+    },
     "routes": {
       "type": "array",
       "description": "The routes to render.",
@@ -26,8 +30,11 @@
   },
   "required": [
     "browserTarget",
-    "serverTarget",
-    "routes"
+    "serverTarget"
+  ],
+  "anyOf": [
+    { "required": ["routes"] },
+    { "required": ["routesFile"] }
   ],
   "additionalProperties": false
 }

modules/builders/src/prerender/schema.ts

@@ -6,15 +6,19 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
- export interface Schema {
+export interface Schema {
   /**
    * Target to build.
    */
   browserTarget: string;
   /**
    * The routes to render.
    */
-  routes: string[];
+  routes?: string[];
+  /**
+   * The path to a file containing routes separated by newlines.
+   */
+  routesFile?: string;
   /**
    * Server target to use for prerendering the app.
    */

modules/builders/src/prerender/utils.spec.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import { getRoutes } from './utils';
+import * as fs from 'fs';
+
+describe('Prerender Builder Utils', () => {
+  describe('#getRoutes', () => {
+    const WORKSPACE_ROOT = '/path/to/angular/json';
+    const ROUTES_FILE = './routes.txt';
+    const ROUTES_FILE_CONTENT = ['/route1', '/route1', '/route2', '/route3'].join('\n');
+    const ROUTES = ['/route3', '/route3', '/route4'];
+
+    beforeEach(() => {
+      spyOn(fs, 'readFileSync').and.returnValue(ROUTES_FILE_CONTENT);
+    });
+
+    it('Should return the deduped union of options.routes and options.routesFile - routes and routesFile defined', () => {
+      const routes = getRoutes(WORKSPACE_ROOT, ROUTES_FILE, ROUTES);
+      expect(routes).toEqual(['/route1', '/route2', '/route3', '/route4']);
+    });
+
+    it('Should return the deduped union of options.routes and options.routesFile - only routes defined', () => {
+      const routes = getRoutes(WORKSPACE_ROOT, undefined, ROUTES);
+      expect(routes).toEqual(['/route3', '/route4']);
+    });
+
+    it('Should return the deduped union of options.routes and options.routesFile - only routes file defined', () => {
+      const routes = getRoutes(WORKSPACE_ROOT, ROUTES_FILE, undefined);
+      expect(routes).toEqual(['/route1', '/route2', '/route3']);
+    });
+  });
+});

modules/builders/src/prerender/utils.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Returns the concatenation of options.routes and the contents of options.routesFile.
+ */
+export function getRoutes(
+  workspaceRoot: string,
+  routesFile?: string,
+  routes: string[] = [],
+): string[] {
+  let routesFileResult: string[] = [];
+  if (routesFile) {
+    const routesFilePath = path.resolve(workspaceRoot, routesFile);
+
+    routesFileResult = fs.readFileSync(routesFilePath, 'utf8')
+      .split(/\r?\n/)
+      .filter(v => !!v);
+  }
+
+  return [...new Set([...routesFileResult, ...routes])];
+}