refactor(@angular-devkit/build-angular): use project metadata in builders

This eliminates the need to manually read a workspace file and removes the use of the experimental workspace API from the package.

Author: clydin

packages/angular_devkit/build_angular/src/app-shell/index.ts

@@ -11,7 +11,7 @@ import {
   createBuilder,
   targetFromTargetString,
 } from '@angular-devkit/architect';
-import { JsonObject, experimental, join, normalize, resolve, schema } from '@angular-devkit/core';
+import { JsonObject, join, normalize, resolve, schema } from '@angular-devkit/core';
 import { NodeJsSyncHost } from '@angular-devkit/core/node';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -81,21 +81,17 @@ async function _renderUniversal(
 
   if (browserOptions.serviceWorker) {
     const host = new NodeJsSyncHost();
-    // Create workspace.
-    const registry = new schema.CoreSchemaRegistry();
-    registry.addPostTransform(schema.transforms.addUndefinedDefaults);
-
-    const workspace = await experimental.workspace.Workspace.fromPath(
-      host,
-      normalize(context.workspaceRoot),
-      registry,
-    );
-    const projectName = context.target ? context.target.project : workspace.getDefaultProjectName();
 
+    const projectName = context.target && context.target.project;
     if (!projectName) {
-      throw new Error('Must either have a target from the context or a default project.');
+      throw new Error('The builder requires a target.');
     }
-    const projectRoot = resolve(workspace.root, normalize(workspace.getProject(projectName).root));
+
+    const projectMetadata = await context.getProjectMetadata(projectName);
+    const projectRoot = resolve(
+      normalize(context.workspaceRoot),
+      normalize((projectMetadata.root as string) || ''),
+    );
 
     await augmentAppWithServiceWorker(
       host,

packages/angular_devkit/build_angular/src/browser/index.ts

@@ -13,7 +13,6 @@ import {
   runWebpack,
 } from '@angular-devkit/build-webpack';
 import {
-  experimental,
   getSystemPath,
   join,
   json,
@@ -108,7 +107,7 @@ export async function buildBrowserWebpackConfigFromContext(
   options: BrowserBuilderSchema,
   context: BuilderContext,
   host: virtualFs.Host<fs.Stats> = new NodeJsSyncHost(),
-): Promise<{ workspace: experimental.workspace.Workspace; config: webpack.Configuration[] }> {
+): Promise<{ config: webpack.Configuration[], projectRoot: string, projectSourceRoot?: string }> {
   return generateBrowserWebpackConfigFromContext(
     options,
     context,
@@ -160,8 +159,12 @@ async function initialize(
   context: BuilderContext,
   host: virtualFs.Host<fs.Stats>,
   webpackConfigurationTransform?: ExecutionTransformer<webpack.Configuration>,
-): Promise<{ workspace: experimental.workspace.Workspace; config: webpack.Configuration[] }> {
-  const { config, workspace } = await buildBrowserWebpackConfigFromContext(options, context, host);
+): Promise<{ config: webpack.Configuration[]; projectRoot: string; projectSourceRoot?: string }> {
+  const { config, projectRoot, projectSourceRoot } = await buildBrowserWebpackConfigFromContext(
+    options,
+    context,
+    host,
+  );
 
   let transformedConfig;
   if (webpackConfigurationTransform) {
@@ -179,7 +182,7 @@ async function initialize(
     ).toPromise();
   }
 
-  return { config: transformedConfig || config, workspace };
+  return { config: transformedConfig || config, projectRoot, projectSourceRoot };
 }
 
 // tslint:disable-next-line: no-big-function
@@ -203,23 +206,10 @@ export function buildWebpackBrowser(
 
   return from(initialize(options, context, host, transforms.webpackConfiguration)).pipe(
     // tslint:disable-next-line: no-big-function
-    switchMap(({ workspace, config: configs }) => {
-      const projectName = context.target
-        ? context.target.project
-        : workspace.getDefaultProjectName();
-
-      if (!projectName) {
-        throw new Error('Must either have a target from the context or a default project.');
-      }
-
-      const projectRoot = resolve(
-        workspace.root,
-        normalize(workspace.getProject(projectName).root),
-      );
-
+    switchMap(({ config: configs, projectRoot }) => {
       const tsConfig = readTsconfig(options.tsConfig, context.workspaceRoot);
       const target = tsConfig.options.target || ScriptTarget.ES5;
-      const buildBrowserFeatures = new BuildBrowserFeatures(getSystemPath(projectRoot), target);
+      const buildBrowserFeatures = new BuildBrowserFeatures(projectRoot, target);
 
       const isDifferentialLoadingNeeded = buildBrowserFeatures.isDifferentialLoadingNeeded();
 
@@ -570,7 +560,7 @@ export function buildWebpackBrowser(
               augmentAppWithServiceWorker(
                 host,
                 root,
-                projectRoot,
+                normalize(projectRoot),
                 resolve(root, normalize(options.outputPath)),
                 options.baseHref || '/',
                 options.ngswConfigPath,

packages/angular_devkit/build_angular/src/dev-server/index.ts

@@ -13,12 +13,8 @@ import {
   runWebpackDevServer,
 } from '@angular-devkit/build-webpack';
 import {
-  experimental,
-  getSystemPath,
   json,
   logging,
-  normalize,
-  resolve,
   tags,
 } from '@angular-devkit/core';
 import { NodeJsSyncHost } from '@angular-devkit/core/node';
@@ -98,7 +94,7 @@ export function serveWebpackBrowser(
     webpackConfig: webpack.Configuration;
     webpackDevServerConfig: WebpackDevServer.Configuration;
     port: number;
-    workspace: experimental.workspace.Workspace;
+    projectRoot: string;
   }> {
     // Get the browser configuration from the target name.
     const rawBrowserOptions = await context.getTargetOptions(browserTarget);
@@ -149,12 +145,12 @@ export function serveWebpackBrowser(
       webpackConfig,
       webpackDevServerConfig,
       port,
-      workspace: webpackConfigResult.workspace,
+      projectRoot: webpackConfigResult.projectRoot,
     };
   }
 
   return from(setup()).pipe(
-    switchMap(({ browserOptions, webpackConfig, webpackDevServerConfig, port, workspace }) => {
+    switchMap(({ browserOptions, webpackConfig, webpackDevServerConfig, port, projectRoot }) => {
       options.port = port;
 
       // Resolve public host and client address.
@@ -192,21 +188,9 @@ export function serveWebpackBrowser(
 
       if (browserOptions.index) {
         const { scripts = [], styles = [], baseHref, tsConfig } = browserOptions;
-        const projectName = context.target
-          ? context.target.project
-          : workspace.getDefaultProjectName();
-
-        if (!projectName) {
-          throw new Error('Must either have a target from the context or a default project.');
-        }
-        const projectRoot = resolve(
-          workspace.root,
-          normalize(workspace.getProject(projectName).root),
-        );
-
         const { options: compilerOptions } = readTsconfig(tsConfig, context.workspaceRoot);
         const target = compilerOptions.target || ts.ScriptTarget.ES5;
-        const buildBrowserFeatures = new BuildBrowserFeatures(getSystemPath(projectRoot), target);
+        const buildBrowserFeatures = new BuildBrowserFeatures(projectRoot, target);
 
         const entrypoints = generateEntryPoints({ scripts, styles });
         const moduleEntrypoints = buildBrowserFeatures.isDifferentialLoadingNeeded()

packages/angular_devkit/build_angular/src/karma/index.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BuilderContext, BuilderOutput, createBuilder } from '@angular-devkit/architect';
-import { experimental, getSystemPath, join } from '@angular-devkit/core';
+import { getSystemPath, join, normalize } from '@angular-devkit/core';
 import { dirname, resolve } from 'path';
 import { Observable, from } from 'rxjs';
 import { defaultIfEmpty, switchMap } from 'rxjs/operators';
@@ -40,8 +40,8 @@ async function initialize(
   context: BuilderContext,
   webpackConfigurationTransformer?: ExecutionTransformer<webpack.Configuration>,
   // tslint:disable-next-line:no-implicit-dependencies
-): Promise<[experimental.workspace.Workspace, typeof import('karma'), webpack.Configuration]> {
-  const { config, workspace } = await generateBrowserWebpackConfigFromContext(
+): Promise<[typeof import('karma'), webpack.Configuration]> {
+  const { config } = await generateBrowserWebpackConfigFromContext(
     // only two properties are missing:
     // * `outputPath` which is fixed for tests
     // * `budgets` which might be incorrect due to extra dev libs
@@ -60,7 +60,6 @@ async function initialize(
   const karma = await import('karma');
 
   return [
-    workspace,
     karma,
     webpackConfigurationTransformer ? await webpackConfigurationTransformer(config[0]) : config[0],
   ];
@@ -80,7 +79,7 @@ export function execute(
 
   return from(initialize(options, context, transforms.webpackConfiguration)).pipe(
     switchMap(
-      ([workspace, karma, webpackConfig]) =>
+      ([karma, webpackConfig]) =>
         new Observable<BuilderOutput>(subscriber => {
           const karmaOptions: KarmaConfigOptions = {};
 
@@ -111,12 +110,10 @@ export function execute(
             options.include &&
             options.include.length > 0
           ) {
-            const mainFilePath = getSystemPath(join(workspace.root, options.main));
-            const files = findTests(
-              options.include,
-              dirname(mainFilePath),
-              getSystemPath(workspace.root),
+            const mainFilePath = getSystemPath(
+              join(normalize(context.workspaceRoot), options.main),
             );
+            const files = findTests(options.include, dirname(mainFilePath), context.workspaceRoot);
             // early exit, no reason to start karma
             if (!files.length) {
               subscriber.error(

packages/angular_devkit/build_angular/src/utils/webpack-browser-config.ts

@@ -7,12 +7,10 @@
  */
 import { BuilderContext } from '@angular-devkit/architect';
 import {
-  experimental,
   getSystemPath,
   logging,
   normalize,
   resolve,
-  schema,
   virtualFs,
 } from '@angular-devkit/core';
 import { NodeJsSyncHost } from '@angular-devkit/core/node';
@@ -60,9 +58,10 @@ export async function generateWebpackConfig(
   // However this config generation is used by multiple builders such as dev-server
   const scriptTarget = tsConfig.options.target || ts.ScriptTarget.ES5;
   const buildBrowserFeatures = new BuildBrowserFeatures(projectRoot, scriptTarget);
-  const differentialLoading = context.builder.builderName === 'browser'
-    && !options.watch
-    && buildBrowserFeatures.isDifferentialLoadingNeeded();
+  const differentialLoading =
+    context.builder.builderName === 'browser' &&
+    !options.watch &&
+    buildBrowserFeatures.isDifferentialLoadingNeeded();
 
   const scriptTargets = [scriptTarget];
 
@@ -73,29 +72,32 @@ export async function generateWebpackConfig(
   // For differential loading, we can have several targets
   return scriptTargets.map(scriptTarget => {
     let buildOptions: NormalizedBrowserBuilderSchema = { ...options };
-    const supportES2015
-      = scriptTarget !== ts.ScriptTarget.ES3 && scriptTarget !== ts.ScriptTarget.ES5;
+    const supportES2015 =
+      scriptTarget !== ts.ScriptTarget.ES3 && scriptTarget !== ts.ScriptTarget.ES5;
 
     if (differentialLoading && fullDifferential) {
       buildOptions = {
         ...options,
-        ...(
-          // FIXME: we do create better webpack config composition to achieve the below
-          // When DL is enabled and supportES2015 is true it means that we are on the second build
-          // This also means that we don't need to include styles and assets multiple times
-          supportES2015
-            ? {}
-            : {
+        ...// FIXME: we do create better webpack config composition to achieve the below
+        // When DL is enabled and supportES2015 is true it means that we are on the second build
+        // This also means that we don't need to include styles and assets multiple times
+        (supportES2015
+          ? {}
+          : {
               styles: options.extractCss ? [] : options.styles,
               assets: [],
-            }
-        ),
+            }),
         es5BrowserSupport: undefined,
         esVersionInFileName: true,
         scriptTargetOverride: scriptTarget,
       };
     } else if (differentialLoading && !fullDifferential) {
-      buildOptions = { ...options, esVersionInFileName: true, scriptTargetOverride: ts.ScriptTarget.ES5, es5BrowserSupport: undefined };
+      buildOptions = {
+        ...options,
+        esVersionInFileName: true,
+        scriptTargetOverride: ts.ScriptTarget.ES5,
+        es5BrowserSupport: undefined,
+      };
     }
 
     const wco: BrowserWebpackConfigOptions = {
@@ -145,75 +147,48 @@ export async function generateWebpackConfig(
   });
 }
 
-
-export async function generateBrowserWebpackConfigFromWorkspace(
+export async function generateBrowserWebpackConfigFromContext(
   options: BrowserBuilderSchema,
   context: BuilderContext,
-  projectName: string,
-  workspace: experimental.workspace.Workspace,
-  host: virtualFs.Host<fs.Stats>,
   webpackPartialGenerator: (wco: BrowserWebpackConfigOptions) => webpack.Configuration[],
-  logger: logging.LoggerApi,
-): Promise<webpack.Configuration[]> {
-  // TODO: Use a better interface for workspace access.
-  const projectRoot = resolve(workspace.root, normalize(workspace.getProject(projectName).root));
-  const projectSourceRoot = workspace.getProject(projectName).sourceRoot;
+  host: virtualFs.Host<fs.Stats> = new NodeJsSyncHost(),
+): Promise<{ config: webpack.Configuration[]; projectRoot: string; projectSourceRoot?: string }> {
+  const projectName = context.target && context.target.project;
+  if (!projectName) {
+    throw new Error('The builder requires a target.');
+  }
+
+  const workspaceRoot = normalize(context.workspaceRoot);
+  const projectMetadata = await context.getProjectMetadata(projectName);
+  const projectRoot = resolve(workspaceRoot, normalize((projectMetadata.root as string) || ''));
+  const projectSourceRoot = projectMetadata.sourceRoot as string | undefined;
   const sourceRoot = projectSourceRoot
-    ? resolve(workspace.root, normalize(projectSourceRoot))
+    ? resolve(workspaceRoot, normalize(projectSourceRoot))
     : undefined;
 
   const normalizedOptions = normalizeBrowserSchema(
     host,
-    workspace.root,
+    workspaceRoot,
     projectRoot,
     sourceRoot,
     options,
   );
 
-  return generateWebpackConfig(
+  const config = await generateWebpackConfig(
     context,
-    getSystemPath(workspace.root),
+    getSystemPath(workspaceRoot),
     getSystemPath(projectRoot),
     sourceRoot && getSystemPath(sourceRoot),
     normalizedOptions,
     webpackPartialGenerator,
-    logger,
-  );
-}
-
-
-export async function generateBrowserWebpackConfigFromContext(
-  options: BrowserBuilderSchema,
-  context: BuilderContext,
-  webpackPartialGenerator: (wco: BrowserWebpackConfigOptions) => webpack.Configuration[],
-  host: virtualFs.Host<fs.Stats> = new NodeJsSyncHost(),
-): Promise<{ workspace: experimental.workspace.Workspace, config: webpack.Configuration[] }> {
-  const registry = new schema.CoreSchemaRegistry();
-  registry.addPostTransform(schema.transforms.addUndefinedDefaults);
-
-  const workspace = await experimental.workspace.Workspace.fromPath(
-    host,
-    normalize(context.workspaceRoot),
-    registry,
-  );
-
-  const projectName = context.target ? context.target.project : workspace.getDefaultProjectName();
-
-  if (!projectName) {
-    throw new Error('Must either have a target from the context or a default project.');
-  }
-
-  const config = await generateBrowserWebpackConfigFromWorkspace(
-    options,
-    context,
-    projectName,
-    workspace,
-    host,
-    webpackPartialGenerator,
     context.logger,
   );
 
-  return { workspace, config };
+  return {
+    config,
+    projectRoot: getSystemPath(projectRoot),
+    projectSourceRoot: sourceRoot && getSystemPath(sourceRoot),
+  };
 }
 
 export function getIndexOutputFile(options: BrowserBuilderSchema): string {