feat(@angular-devkit/core): add default project

Partially address #10352

Author: filipesilva

packages/angular_devkit/architect/src/architect.ts

@@ -188,7 +188,7 @@ export class Architect {
     }
 
     const builderConfiguration: BuilderConfiguration<OptionsT> = {
-      root: project.root,
+      root: project.root as Path,
       projectType: project.projectType,
       builder: target.builder,
       options: {

packages/angular_devkit/core/src/workspace/workspace-schema.json

@@ -17,6 +17,10 @@
       "description": "New project root.",
       "default": "./"
     },
+    "defaultProject": {
+      "type": "string",
+      "description": "The default project."
+    },
     "cli": {
       "$ref": "#/definitions/tool",
       "default": {}

packages/angular_devkit/core/src/workspace/workspace-schema.ts

@@ -19,47 +19,33 @@ export interface WorkspaceSchema {
    * New project root.
    */
   newProjectRoot?: string;
+  /**
+   * The default project.
+   */
+  defaultProject?: string;
   /**
    * Tool options.
    */
-  cli?: {
-    /**
-     * Link to schema.
-     */
-    $schema?: string;
-    [k: string]: any;
-  };
+  cli?: WorkspaceTool;
   /**
    * Tool options.
    */
-  schematics?: {
-    /**
-     * Link to schema.
-     */
-    $schema?: string;
-    [k: string]: any;
-  };
+  schematics?: WorkspaceTool;
   /**
    * Tool options.
    */
-  architect?: {
-    /**
-     * Link to schema.
-     */
-    $schema?: string;
-    [k: string]: any;
-  };
+  architect?: WorkspaceTool;
   /**
    * A map of project names to project options.
    */
   projects: {
-    [k: string]: Project;
+    [k: string]: WorkspaceProject;
   };
 }
 /**
  * Project options.
  */
-export interface Project {
+export interface WorkspaceProject {
   /**
    * Project type.
    */
@@ -75,32 +61,20 @@ export interface Project {
   /**
    * Tool options.
    */
-  cli?: {
-    /**
-     * Link to schema.
-     */
-    $schema?: string;
-    [k: string]: any;
-  };
+  cli?: WorkspaceTool;
   /**
    * Tool options.
    */
-  schematics?: {
-    /**
-     * Link to schema.
-     */
-    $schema?: string;
-    [k: string]: any;
-  };
+  schematics?: WorkspaceTool;
   /**
    * Tool options.
    */
-  architect?: Architect;
+  architect?: WorkspaceTool;
 }
 /**
  * Architect options.
  */
-export interface Architect {
+export interface WorkspaceTool {
   /**
    * Link to schema.
    */

packages/angular_devkit/core/src/workspace/workspace.ts

@@ -19,9 +19,7 @@ import {
   virtualFs,
 } from '..';
 import { BaseException } from '../exception/exception';
-// Note: importing BaseException from '..' seems to lead to odd circular dependency errors.
-// TypeError: Class extends value undefined is not a constructor or null
-// at Object.<anonymous> (<path>\packages\angular_devkit\core\src\workspace\workspace.ts:19:44)
+import { WorkspaceProject, WorkspaceSchema, WorkspaceTool } from './workspace-schema';
 
 
 export class ProjectNotFoundException extends BaseException {
@@ -46,30 +44,11 @@ export class WorkspaceNotYetLoadedException extends BaseException {
   constructor() { super(`Workspace needs to be loaded before it is used.`); }
 }
 
-export interface WorkspaceJson {
-  version: number;
-  // TODO: figure out if newProjectRoot should stay here.
-  newProjectRoot: Path;
-  cli: WorkspaceTool;
-  schematics: WorkspaceTool;
-  architect: WorkspaceTool;
-  projects: { [k: string]: WorkspaceProject };
-}
-
-export interface WorkspaceProject {
-  projectType: 'application' | 'library';
-  root: Path;
-  cli: WorkspaceTool;
-  schematics: WorkspaceTool;
-  architect: WorkspaceTool;
-}
-
-export interface WorkspaceTool extends JsonObject { }
 
 export class Workspace {
   private readonly _workspaceSchemaPath = join(normalize(__dirname), 'workspace-schema.json');
   private _workspaceSchema: JsonObject;
-  private _workspace: WorkspaceJson;
+  private _workspace: WorkspaceSchema;
   private _registry: schema.CoreSchemaRegistry;
 
   constructor(private _root: Path, private _host: virtualFs.Host<{}>) {
@@ -79,7 +58,7 @@ export class Workspace {
   loadWorkspaceFromJson(json: {}) {
     return this._loadWorkspaceSchema().pipe(
       concatMap((workspaceSchema) => this.validateAgainstSchema(json, workspaceSchema)),
-      tap((validatedWorkspace: WorkspaceJson) => this._workspace = validatedWorkspace),
+      tap((validatedWorkspace: WorkspaceSchema) => this._workspace = validatedWorkspace),
       map(() => this),
     );
   }
@@ -149,6 +128,21 @@ export class Workspace {
     };
   }
 
+  getDefaultProject() {
+    this._assertLoaded();
+
+    if (this._workspace.defaultProject) {
+      // If there is a default project name, return it.
+      return this.getProject(this._workspace.defaultProject);
+    } else if (this.listProjectNames().length === 1) {
+      // If there is only one project, return that one.
+      return this.getProject(this.listProjectNames()[0]);
+    }
+
+    // Otherwise return null.
+    return null;
+  }
+
   getCli() {
     return this._getTool('cli');
   }

packages/angular_devkit/core/src/workspace/workspace_spec.ts

@@ -14,18 +14,19 @@ import {
   ProjectNotFoundException,
   Workspace,
   WorkspaceNotYetLoadedException,
-  WorkspaceProject,
 } from './workspace';
+import { WorkspaceProject, WorkspaceSchema, WorkspaceTool } from './workspace-schema';
 
 
 describe('Workspace', () => {
   const host = new NodeJsSyncHost();
   const root = normalize(__dirname);
   // The content of this JSON object should be kept in sync with the path below:
   // tests/@angular_devkit/workspace/angular-workspace.json
-  const workspaceJson = {
+  const workspaceJson: WorkspaceSchema = {
     version: 1,
     newProjectRoot: './projects',
+    defaultProject: 'app',
     cli: {
       '$globalOverride': '${HOME}/.angular-cli.json',
       'schematics': {
@@ -98,6 +99,13 @@ describe('Workspace', () => {
       },
     },
   };
+  const appProject = {
+    ...workspaceJson.projects['app'],
+    // Tools should not be returned when getting a project.
+    cli: {},
+    schematics: {},
+    architect: {},
+  } as {} as WorkspaceProject;
 
   it('loads workspace from json', (done) => {
     const workspace = new Workspace(root, host);
@@ -168,13 +176,7 @@ describe('Workspace', () => {
   it('gets project by name', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
-      tap((ws) => expect(ws.getProject('app')).toEqual({
-        ...workspaceJson.projects['app'],
-        // Tools should not be returned when getting a project.
-        cli: {},
-        schematics: {},
-        architect: {},
-      } as {} as WorkspaceProject)),
+      tap((ws) => expect(ws.getProject('app')).toEqual(appProject)),
     ).subscribe(undefined, done.fail, done);
   });
 
@@ -185,47 +187,71 @@ describe('Workspace', () => {
     ).subscribe(undefined, done.fail, done);
   });
 
+  it('gets default project', (done) => {
+    const workspace = new Workspace(root, host);
+    workspace.loadWorkspaceFromJson(workspaceJson).pipe(
+      tap((ws) => expect(ws.getDefaultProject()).toEqual(appProject)),
+    ).subscribe(undefined, done.fail, done);
+  });
+
+  it('gets default project when there is a single one', (done) => {
+    const customWorkspaceJson = { ...workspaceJson, defaultProject: undefined };
+    const workspace = new Workspace(root, host);
+    workspace.loadWorkspaceFromJson(customWorkspaceJson).pipe(
+      tap((ws) => expect(ws.getDefaultProject()).toEqual(appProject)),
+    ).subscribe(undefined, done.fail, done);
+  });
+
+  it('gets default project when there is a single one', (done) => {
+    const customWorkspaceJson = { ...workspaceJson, defaultProject: undefined, projects: {} };
+    const workspace = new Workspace(root, host);
+    workspace.loadWorkspaceFromJson(customWorkspaceJson).pipe(
+      tap((ws) => expect(ws.getDefaultProject()).toEqual(null)),
+    ).subscribe(undefined, done.fail, done);
+  });
+
   it('gets workspace cli', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
-      tap((ws) => expect(ws.getCli()).toEqual(workspaceJson.cli)),
+      tap((ws) => expect(ws.getCli()).toEqual(workspaceJson.cli as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 
   it('gets workspace schematics', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
-      tap((ws) => expect(ws.getSchematics()).toEqual(workspaceJson.schematics)),
+      tap((ws) => expect(ws.getSchematics()).toEqual(workspaceJson.schematics as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 
   it('gets workspace architect', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
-      tap((ws) => expect(ws.getArchitect()).toEqual(workspaceJson.architect)),
+      tap((ws) => expect(ws.getArchitect()).toEqual(workspaceJson.architect as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 
   it('gets project cli', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
-      tap((ws) => expect(ws.getProjectCli('app')).toEqual(workspaceJson.projects.app.cli)),
+      tap((ws) => expect(ws.getProjectCli('app'))
+        .toEqual(workspaceJson.projects.app.cli as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 
   it('gets project schematics', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
       tap((ws) => expect(ws.getProjectSchematics('app'))
-        .toEqual(workspaceJson.projects.app.schematics)),
+        .toEqual(workspaceJson.projects.app.schematics as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 
   it('gets project architect', (done) => {
     const workspace = new Workspace(root, host);
     workspace.loadWorkspaceFromJson(workspaceJson).pipe(
       tap((ws) => expect(ws.getProjectArchitect('app'))
-        .toEqual(workspaceJson.projects.app.architect)),
+        .toEqual(workspaceJson.projects.app.architect as WorkspaceTool)),
     ).subscribe(undefined, done.fail, done);
   });
 

packages/schematics/angular/app-shell/index.ts

@@ -16,9 +16,9 @@ import {
 } from '@angular-devkit/schematics';
 import * as ts from 'typescript';
 import {
-  Architect,
-  Project,
+  WorkspaceProject,
   WorkspaceSchema,
+  WorkspaceTool,
 } from '../../../angular_devkit/core/src/workspace/workspace-schema';
 import { Schema as ComponentOptions } from '../component/schema';
 import {
@@ -54,7 +54,9 @@ function getSourceFile(host: Tree, path: string): ts.SourceFile {
   return source;
 }
 
-function getServerModulePath(host: Tree, project: Project, architect: Architect): string | null {
+function getServerModulePath(
+  host: Tree, project: WorkspaceProject, architect: WorkspaceTool,
+): string | null {
   const mainPath = architect.server.options.main;
   const mainSource = getSourceFile(host, mainPath);
   const allNodes = getSourceNodes(mainSource);
@@ -102,7 +104,7 @@ function getComponentTemplate(host: Tree, compPath: string, tmplInfo: TemplateIn
   return template;
 }
 
-function getBootstrapComponentPath(host: Tree, project: Project): string {
+function getBootstrapComponentPath(host: Tree, project: WorkspaceProject): string {
   if (!project.architect) {
     throw new Error('Project architect not found.');
   }
@@ -317,7 +319,7 @@ function addShellComponent(options: AppShellOptions): Rule {
   };
 }
 
-function getClientProject(host: Tree, options: AppShellOptions): Project {
+function getClientProject(host: Tree, options: AppShellOptions): WorkspaceProject {
   const workspace = getWorkspace(host);
   const clientProject = workspace.projects[options.clientProject];
   if (!clientProject) {
@@ -327,7 +329,7 @@ function getClientProject(host: Tree, options: AppShellOptions): Project {
   return clientProject;
 }
 
-function getClientArchitect(host: Tree, options: AppShellOptions): Architect {
+function getClientArchitect(host: Tree, options: AppShellOptions): WorkspaceTool {
   const clientArchitect = getClientProject(host, options).architect;
 
   if (!clientArchitect) {

packages/schematics/angular/universal/index.ts

@@ -39,7 +39,9 @@ function getWorkspacePath(host: Tree): string {
   return possibleFiles.filter(path => host.exists(path))[0];
 }
 
-function getClientProject(host: Tree, options: UniversalOptions): experimental.workspace.Project {
+function getClientProject(
+  host: Tree, options: UniversalOptions,
+): experimental.workspace.WorkspaceProject {
   const workspace = getWorkspace(host);
   const clientProject = workspace.projects[options.clientProject];
   if (!clientProject) {
@@ -52,7 +54,7 @@ function getClientProject(host: Tree, options: UniversalOptions): experimental.w
 function getClientArchitect(
   host: Tree,
   options: UniversalOptions,
-): experimental.workspace.Architect {
+): experimental.workspace.WorkspaceTool {
   const clientArchitect = getClientProject(host, options).architect;
 
   if (!clientArchitect) {
@@ -181,7 +183,7 @@ function addDependencies(): Rule {
   };
 }
 
-function getTsConfigOutDir(host: Tree, architect: experimental.workspace.Architect): string {
+function getTsConfigOutDir(host: Tree, architect: experimental.workspace.WorkspaceTool): string {
   const tsConfigPath = architect.build.options.tsConfig;
   const tsConfigBuffer = host.read(tsConfigPath);
   if (!tsConfigBuffer) {