@angular/cli 14.0.0-next.5 → 14.0.0-next.8

package/src/command-builder/command-module.js

@@ -8,7 +8,11 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,6 +22,12 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -32,6 +42,7 @@ const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const helpers_1 = require("yargs/helpers");
 const analytics_1 = require("../analytics/analytics");
+const memoize_1 = require("../utilities/memoize");
 var CommandScope;
 (function (CommandScope) {
     /** Command can only run inside an Angular workspace. */
@@ -63,7 +74,7 @@ class CommandModule {
                         longDescriptionRelativePath: path
                             .relative(path.join(__dirname, '../../../../'), this.longDescriptionPath)
                             .replace(/\\/g, path.posix.sep),
-                        longDescription: (0, fs_1.readFileSync)(this.longDescriptionPath, 'utf8'),
+                        longDescription: (0, fs_1.readFileSync)(this.longDescriptionPath, 'utf8').replace(/\r\n/g, '\n'),
                     }
                     : {}),
             };
@@ -120,11 +131,10 @@ class CommandModule {
             metrics: [],
         });
     }
-    async getAnalytics() {
-        if (this._analytics) {
-            return this._analytics;
-        }
-        return (this._analytics = await (0, analytics_1.createAnalytics)(!!this.context.workspace, this.commandName === 'update'));
+    getAnalytics() {
+        return (0, analytics_1.createAnalytics)(!!this.context.workspace, 
+        // Don't prompt for `ng update` and `ng analytics` commands.
+        ['update', 'analytics'].includes(this.commandName));
     }
     /**
      * Adds schema options to a command also this keeps track of options that are required for analytics.
@@ -174,8 +184,11 @@ class CommandModule {
         return workspace;
     }
 }
-exports.CommandModule = CommandModule;
 CommandModule.scope = CommandScope.Both;
+__decorate([
+    memoize_1.memoize
+], CommandModule.prototype, "getAnalytics", null);
+exports.CommandModule = CommandModule;
 /**
  * Creates an known command module error.
  * This is used so during executation we can filter between known validation error and real non handled errors.

package/src/command-builder/command-runner.d.ts

@@ -6,5 +6,4 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { logging } from '@angular-devkit/core';
-import { AngularWorkspace } from '../utilities/config';
-export declare function runCommand(args: string[], logger: logging.Logger, workspace: AngularWorkspace | undefined): Promise<number>;
+export declare function runCommand(args: string[], logger: logging.Logger): Promise<number>;

package/src/command-builder/command-runner.js

@@ -16,55 +16,76 @@ const helpers_1 = require("yargs/helpers");
 const cli_1 = require("../commands/add/cli");
 const cli_2 = require("../commands/analytics/cli");
 const cli_3 = require("../commands/build/cli");
-const cli_4 = require("../commands/config/cli");
-const cli_5 = require("../commands/deploy/cli");
-const cli_6 = require("../commands/doc/cli");
-const cli_7 = require("../commands/e2e/cli");
-const cli_8 = require("../commands/extract-i18n/cli");
-const cli_9 = require("../commands/generate/cli");
-const cli_10 = require("../commands/lint/cli");
-const cli_11 = require("../commands/make-this-awesome/cli");
-const cli_12 = require("../commands/new/cli");
-const cli_13 = require("../commands/run/cli");
-const cli_14 = require("../commands/serve/cli");
-const cli_15 = require("../commands/test/cli");
-const cli_16 = require("../commands/update/cli");
-const cli_17 = require("../commands/version/cli");
+const cli_4 = require("../commands/cache/cli");
+const cli_5 = require("../commands/config/cli");
+const cli_6 = require("../commands/deploy/cli");
+const cli_7 = require("../commands/doc/cli");
+const cli_8 = require("../commands/e2e/cli");
+const cli_9 = require("../commands/extract-i18n/cli");
+const cli_10 = require("../commands/generate/cli");
+const cli_11 = require("../commands/lint/cli");
+const cli_12 = require("../commands/make-this-awesome/cli");
+const cli_13 = require("../commands/new/cli");
+const cli_14 = require("../commands/run/cli");
+const cli_15 = require("../commands/serve/cli");
+const cli_16 = require("../commands/test/cli");
+const cli_17 = require("../commands/update/cli");
+const cli_18 = require("../commands/version/cli");
 const color_1 = require("../utilities/color");
+const config_1 = require("../utilities/config");
+const package_manager_1 = require("../utilities/package-manager");
 const command_module_1 = require("./command-module");
+const command_1 = require("./utilities/command");
 const json_help_1 = require("./utilities/json-help");
 const COMMANDS = [
-    cli_17.VersionCommandModule,
-    cli_6.DocCommandModule,
-    cli_11.AwesomeCommandModule,
-    cli_4.ConfigCommandModule,
+    cli_18.VersionCommandModule,
+    cli_7.DocCommandModule,
+    cli_12.AwesomeCommandModule,
+    cli_5.ConfigCommandModule,
     cli_2.AnalyticsCommandModule,
     cli_1.AddCommandModule,
-    cli_9.GenerateCommandModule,
+    cli_10.GenerateCommandModule,
     cli_3.BuildCommandModule,
-    cli_7.E2eCommandModule,
-    cli_15.TestCommandModule,
-    cli_14.ServeCommandModule,
-    cli_8.ExtractI18nCommandModule,
-    cli_5.DeployCommandModule,
-    cli_10.LintCommandModule,
-    cli_12.NewCommandModule,
-    cli_16.UpdateCommandModule,
-    cli_13.RunCommandModule,
-];
+    cli_8.E2eCommandModule,
+    cli_16.TestCommandModule,
+    cli_15.ServeCommandModule,
+    cli_9.ExtractI18nCommandModule,
+    cli_6.DeployCommandModule,
+    cli_11.LintCommandModule,
+    cli_13.NewCommandModule,
+    cli_17.UpdateCommandModule,
+    cli_14.RunCommandModule,
+    cli_4.CacheCommandModule,
+].sort(); // Will be sorted by class name.
 const yargsParser = helpers_1.Parser;
-async function runCommand(args, logger, workspace) {
+async function runCommand(args, logger) {
     var _a, _b;
     const { $0, _: positional, help = false, jsonHelp = false, ...rest } = yargsParser(args, { boolean: ['help', 'json-help'], alias: { 'collection': 'c' } });
+    let workspace;
+    let globalConfiguration;
+    try {
+        [workspace, globalConfiguration] = await Promise.all([
+            (0, config_1.getWorkspace)('local'),
+            (0, config_1.getWorkspace)('global'),
+        ]);
+    }
+    catch (e) {
+        logger.fatal(e.message);
+        return 1;
+    }
+    const root = (_a = workspace === null || workspace === void 0 ? void 0 : workspace.basePath) !== null && _a !== void 0 ? _a : process.cwd();
     const context = {
+        globalConfiguration,
         workspace,
         logger,
         currentDirectory: process.cwd(),
-        root: (_a = workspace === null || workspace === void 0 ? void 0 : workspace.basePath) !== null && _a !== void 0 ? _a : process.cwd(),
+        root,
+        packageManager: new package_manager_1.PackageManagerUtils({ globalConfiguration, workspace, root }),
         args: {
             positional: positional.map((v) => v.toString()),
             options: {
                 help,
+                jsonHelp,
                 ...rest,
             },
         },
@@ -78,22 +99,7 @@ async function runCommand(args, logger, workspace) {
                 continue;
             }
         }
-        const commandModule = new CommandModule(context);
-        const describe = jsonHelp ? commandModule.fullDescribe : commandModule.describe;
-        localYargs = localYargs.command({
-            command: commandModule.command,
-            aliases: 'aliases' in commandModule ? commandModule.aliases : undefined,
-            describe: 
-            // We cannot add custom fields in help, such as long command description which is used in AIO.
-            // Therefore, we get around this by adding a complex object as a string which we later parse when generating the help files.
-            describe !== undefined && typeof describe === 'object'
-                ? JSON.stringify(describe)
-                : describe,
-            deprecated: 'deprecated' in commandModule ? commandModule.deprecated : undefined,
-            builder: (argv) => commandModule.builder(argv),
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            handler: (args) => commandModule.handler(args),
-        });
+        localYargs = (0, command_1.addCommandModuleToYargs)(localYargs, CommandModule, context);
     }
     if (jsonHelp) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -127,7 +133,7 @@ async function runCommand(args, logger, workspace) {
         'deprecated: %s': color_1.colors.yellow('deprecated:') + ' %s',
         'Did you mean %s?': 'Unknown command. Did you mean %s?',
     })
-        .demandCommand()
+        .demandCommand(1, command_1.demandCommandFailureMessage)
         .recommendCommands()
         .version(false)
         .showHelpOnFail(false)

package/src/command-builder/schematics-command-module.d.ts

@@ -8,24 +8,36 @@
 import { Collection } from '@angular-devkit/schematics';
 import { FileSystemCollectionDescription, FileSystemSchematicDescription, NodeWorkflow } from '@angular-devkit/schematics/tools';
 import { Argv } from 'yargs';
-import { CommandModule, CommandModuleImplementation, CommandScope } from './command-module';
+import { CommandModule, CommandModuleImplementation, CommandScope, Options, OtherOptions } from './command-module';
 import { Option } from './utilities/json-schema';
+export declare const DEFAULT_SCHEMATICS_COLLECTION = "@schematics/angular";
 export interface SchematicsCommandArgs {
     interactive: boolean;
     force: boolean;
     'dry-run': boolean;
     defaults: boolean;
 }
+export interface SchematicsExecutionOptions extends Options<SchematicsCommandArgs> {
+    packageRegistry?: string;
+}
 export declare abstract class SchematicsCommandModule extends CommandModule<SchematicsCommandArgs> implements CommandModuleImplementation<SchematicsCommandArgs> {
     static scope: CommandScope;
-    protected readonly schematicName: string | undefined;
+    protected readonly allowPrivateSchematics: boolean;
+    protected readonly shouldReportAnalytics = false;
     builder(argv: Argv): Promise<Argv<SchematicsCommandArgs>>;
     /** Get schematic schema options.*/
     protected getSchematicOptions(collection: Collection<FileSystemCollectionDescription, FileSystemSchematicDescription>, schematicName: string, workflow: NodeWorkflow): Promise<Option[]>;
-    protected getCollectionName(): Promise<string>;
-    private _workflow;
-    protected getOrCreateWorkflow(collectionName: string): NodeWorkflow;
-    private _defaultSchematicCollection;
-    protected getDefaultSchematicCollection(): Promise<string>;
+    protected getOrCreateWorkflowForBuilder(collectionName: string): NodeWorkflow;
+    protected getOrCreateWorkflowForExecution(collectionName: string, options: SchematicsExecutionOptions): Promise<NodeWorkflow>;
+    protected getSchematicCollections(): Promise<Set<string>>;
     protected parseSchematicInfo(schematic: string | undefined): [collectionName: string | undefined, schematicName: string | undefined];
+    protected runSchematic(options: {
+        executionOptions: SchematicsExecutionOptions;
+        schematicOptions: OtherOptions;
+        collectionName: string;
+        schematicName: string;
+    }): Promise<number>;
+    private defaultProjectDeprecationWarningShown;
+    private getProjectName;
+    private getResolvePaths;
 }

package/src/command-builder/schematics-command-module.js

@@ -6,17 +6,57 @@
  * 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
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchematicsCommandModule = void 0;
+exports.SchematicsCommandModule = exports.DEFAULT_SCHEMATICS_COLLECTION = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular-devkit/schematics");
 const tools_1 = require("@angular-devkit/schematics/tools");
-const schematic_engine_host_1 = require("../../models/schematic-engine-host");
 const config_1 = require("../utilities/config");
+const memoize_1 = require("../utilities/memoize");
+const tty_1 = require("../utilities/tty");
 const command_module_1 = require("./command-module");
 const json_schema_1 = require("./utilities/json-schema");
-const DEFAULT_SCHEMATICS_COLLECTION = '@schematics/angular';
+const schematic_engine_host_1 = require("./utilities/schematic-engine-host");
+const schematic_workflow_1 = require("./utilities/schematic-workflow");
+exports.DEFAULT_SCHEMATICS_COLLECTION = '@schematics/angular';
 class SchematicsCommandModule extends command_module_1.CommandModule {
+    constructor() {
+        super(...arguments);
+        this.allowPrivateSchematics = false;
+        this.shouldReportAnalytics = false;
+        this.defaultProjectDeprecationWarningShown = false;
+    }
     async builder(argv) {
-        const localYargs = argv
+        return argv
             .option('interactive', {
             describe: 'Enable interactive input prompts.',
             type: 'boolean',
@@ -38,14 +78,6 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
             default: false,
         })
             .strict();
-        if (this.schematicName) {
-            const collectionName = await this.getCollectionName();
-            const workflow = this.getOrCreateWorkflow(collectionName);
-            const collection = workflow.engine.createCollection(collectionName);
-            const options = await this.getSchematicOptions(collection, this.schematicName, workflow);
-            return this.addSchemaOptionsToCommand(localYargs, options);
-        }
-        return localYargs;
     }
     /** Get schematic schema options.*/
     async getSchematicOptions(collection, schematicName, workflow) {
@@ -56,54 +88,157 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
         }
         return (0, json_schema_1.parseJsonSchemaToOptions)(workflow.registry, schemaJson);
     }
-    async getCollectionName() {
-        var _a, _b;
-        const { options: { collection }, positional, } = this.context.args;
-        return ((_b = (_a = (typeof collection === 'string' ? collection : undefined)) !== null && _a !== void 0 ? _a : 
-        // positional = [generate, lint] or [new, collection-package]
-        this.parseSchematicInfo(positional[1])[0]) !== null && _b !== void 0 ? _b : (await this.getDefaultSchematicCollection()));
-    }
-    getOrCreateWorkflow(collectionName) {
-        if (this._workflow) {
-            return this._workflow;
-        }
-        const { root, workspace } = this.context;
-        return new tools_1.NodeWorkflow(root, {
-            resolvePaths: workspace
-                ? // Workspace
-                    collectionName === DEFAULT_SCHEMATICS_COLLECTION
-                        ? // Favor __dirname for @schematics/angular to use the build-in version
-                            [__dirname, process.cwd(), root]
-                        : [process.cwd(), root, __dirname]
-                : // Global
-                    [__dirname, process.cwd()],
+    getOrCreateWorkflowForBuilder(collectionName) {
+        return new tools_1.NodeWorkflow(this.context.root, {
+            resolvePaths: this.getResolvePaths(collectionName),
             engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
         });
     }
-    async getDefaultSchematicCollection() {
-        if (this._defaultSchematicCollection) {
-            return this._defaultSchematicCollection;
+    async getOrCreateWorkflowForExecution(collectionName, options) {
+        const { logger, root, packageManager } = this.context;
+        const { force, dryRun, packageRegistry } = options;
+        const workflow = new tools_1.NodeWorkflow(root, {
+            force,
+            dryRun,
+            packageManager: packageManager.name,
+            // A schema registry is required to allow customizing addUndefinedDefaults
+            registry: new core_1.schema.CoreSchemaRegistry(schematics_1.formats.standardFormats),
+            packageRegistry,
+            resolvePaths: this.getResolvePaths(collectionName),
+            schemaValidation: true,
+            optionTransforms: [
+                // Add configuration file defaults
+                async (schematic, current) => {
+                    const projectName = typeof current.project === 'string'
+                        ? current.project
+                        : this.getProjectName();
+                    return {
+                        ...(await (0, config_1.getSchematicDefaults)(schematic.collection.name, schematic.name, projectName)),
+                        ...current,
+                    };
+                },
+            ],
+            engineHostCreator: (options) => new schematic_engine_host_1.SchematicEngineHost(options.resolvePaths),
+        });
+        workflow.registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+        workflow.registry.addSmartDefaultProvider('projectName', () => this.getProjectName());
+        workflow.registry.useXDeprecatedProvider((msg) => logger.warn(msg));
+        let shouldReportAnalytics = true;
+        workflow.engineHost.registerOptionsTransform(async (schematic, options) => {
+            var _a;
+            if (shouldReportAnalytics) {
+                shouldReportAnalytics = false;
+                // ng generate lib -> ng generate
+                const commandName = (_a = this.command) === null || _a === void 0 ? void 0 : _a.split(' ', 1)[0];
+                await this.reportAnalytics(options, [
+                    commandName,
+                    schematic.collection.name.replace(/\//g, '_'),
+                    schematic.name.replace(/\//g, '_'),
+                ]);
+            }
+            return options;
+        });
+        if (options.interactive !== false && (0, tty_1.isTTY)()) {
+            workflow.registry.usePromptProvider(async (definitions) => {
+                const questions = definitions
+                    .filter((definition) => !options.defaults || definition.default === undefined)
+                    .map((definition) => {
+                    var _a;
+                    const question = {
+                        name: definition.id,
+                        message: definition.message,
+                        default: definition.default,
+                    };
+                    const validator = definition.validator;
+                    if (validator) {
+                        question.validate = (input) => validator(input);
+                        // Filter allows transformation of the value prior to validation
+                        question.filter = async (input) => {
+                            for (const type of definition.propertyTypes) {
+                                let value;
+                                switch (type) {
+                                    case 'string':
+                                        value = String(input);
+                                        break;
+                                    case 'integer':
+                                    case 'number':
+                                        value = Number(input);
+                                        break;
+                                    default:
+                                        value = input;
+                                        break;
+                                }
+                                // Can be a string if validation fails
+                                const isValid = (await validator(value)) === true;
+                                if (isValid) {
+                                    return value;
+                                }
+                            }
+                            return input;
+                        };
+                    }
+                    switch (definition.type) {
+                        case 'confirmation':
+                            question.type = 'confirm';
+                            break;
+                        case 'list':
+                            question.type = definition.multiselect ? 'checkbox' : 'list';
+                            question.choices = (_a = definition.items) === null || _a === void 0 ? void 0 : _a.map((item) => {
+                                return typeof item == 'string'
+                                    ? item
+                                    : {
+                                        name: item.label,
+                                        value: item.value,
+                                    };
+                            });
+                            break;
+                        default:
+                            question.type = definition.type;
+                            break;
+                    }
+                    return question;
+                });
+                if (questions.length) {
+                    const { prompt } = await Promise.resolve().then(() => __importStar(require('inquirer')));
+                    return prompt(questions);
+                }
+                else {
+                    return {};
+                }
+            });
         }
-        let workspace = await (0, config_1.getWorkspace)('local');
+        return workflow;
+    }
+    async getSchematicCollections() {
+        var _a;
+        const getSchematicCollections = (configSection) => {
+            if (!configSection) {
+                return undefined;
+            }
+            const { schematicCollections, defaultCollection } = configSection;
+            if (Array.isArray(schematicCollections)) {
+                return new Set(schematicCollections);
+            }
+            else if (typeof defaultCollection === 'string') {
+                return new Set([defaultCollection]);
+            }
+            return undefined;
+        };
+        const { workspace, globalConfiguration } = this.context;
         if (workspace) {
             const project = (0, config_1.getProjectByCwd)(workspace);
             if (project) {
-                const value = workspace.getProjectCli(project)['defaultCollection'];
-                if (typeof value == 'string') {
-                    return (this._defaultSchematicCollection = value);
+                const value = getSchematicCollections(workspace.getProjectCli(project));
+                if (value) {
+                    return value;
                 }
             }
-            const value = workspace.getCli()['defaultCollection'];
-            if (typeof value === 'string') {
-                return (this._defaultSchematicCollection = value);
-            }
         }
-        workspace = await (0, config_1.getWorkspace)('global');
-        const value = workspace === null || workspace === void 0 ? void 0 : workspace.getCli()['defaultCollection'];
-        if (typeof value === 'string') {
-            return (this._defaultSchematicCollection = value);
+        const value = (_a = getSchematicCollections(workspace === null || workspace === void 0 ? void 0 : workspace.getCli())) !== null && _a !== void 0 ? _a : getSchematicCollections(globalConfiguration === null || globalConfiguration === void 0 ? void 0 : globalConfiguration.getCli());
+        if (value) {
+            return value;
         }
-        return (this._defaultSchematicCollection = DEFAULT_SCHEMATICS_COLLECTION);
+        return new Set([exports.DEFAULT_SCHEMATICS_COLLECTION]);
     }
     parseSchematicInfo(schematic) {
         if (schematic === null || schematic === void 0 ? void 0 : schematic.includes(':')) {
@@ -112,6 +247,89 @@ class SchematicsCommandModule extends command_module_1.CommandModule {
         }
         return [undefined, schematic];
     }
+    async runSchematic(options) {
+        const { logger } = this.context;
+        const { schematicOptions, executionOptions, collectionName, schematicName } = options;
+        const workflow = await this.getOrCreateWorkflowForExecution(collectionName, executionOptions);
+        if (!schematicName) {
+            throw new Error('schematicName cannot be undefined.');
+        }
+        const { unsubscribe, files } = (0, schematic_workflow_1.subscribeToWorkflow)(workflow, logger);
+        try {
+            await workflow
+                .execute({
+                collection: collectionName,
+                schematic: schematicName,
+                options: schematicOptions,
+                logger,
+                allowPrivate: this.allowPrivateSchematics,
+            })
+                .toPromise();
+            if (!files.size) {
+                logger.info('Nothing to be done.');
+            }
+            if (executionOptions.dryRun) {
+                logger.warn(`\nNOTE: The "--dry-run" option means no changes were made.`);
+            }
+        }
+        catch (err) {
+            // In case the workflow was not successful, show an appropriate error message.
+            if (err instanceof schematics_1.UnsuccessfulWorkflowExecution) {
+                // "See above" because we already printed the error.
+                logger.fatal('The Schematic workflow failed. See above.');
+                return 1;
+            }
+            else {
+                throw err;
+            }
+        }
+        finally {
+            unsubscribe();
+        }
+        return 0;
+    }
+    getProjectName() {
+        const { workspace, logger } = this.context;
+        if (!workspace) {
+            return undefined;
+        }
+        const projectName = (0, config_1.getProjectByCwd)(workspace);
+        if (projectName) {
+            return projectName;
+        }
+        const defaultProjectName = workspace.extensions['defaultProject'];
+        if (typeof defaultProjectName === 'string' && defaultProjectName) {
+            if (!this.defaultProjectDeprecationWarningShown) {
+                logger.warn(core_1.tags.oneLine `
+            DEPRECATED: The 'defaultProject' workspace option has been deprecated.
+            The project to use will be determined from the current working directory.
+          `);
+                this.defaultProjectDeprecationWarningShown = true;
+            }
+            return defaultProjectName;
+        }
+        return undefined;
+    }
+    getResolvePaths(collectionName) {
+        const { workspace, root } = this.context;
+        return workspace
+            ? // Workspace
+                collectionName === exports.DEFAULT_SCHEMATICS_COLLECTION
+                    ? // Favor __dirname for @schematics/angular to use the build-in version
+                        [__dirname, process.cwd(), root]
+                    : [process.cwd(), root, __dirname]
+            : // Global
+                [__dirname, process.cwd()];
+    }
 }
-exports.SchematicsCommandModule = SchematicsCommandModule;
 SchematicsCommandModule.scope = command_module_1.CommandScope.In;
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getOrCreateWorkflowForBuilder", null);
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getOrCreateWorkflowForExecution", null);
+__decorate([
+    memoize_1.memoize
+], SchematicsCommandModule.prototype, "getSchematicCollections", null);
+exports.SchematicsCommandModule = SchematicsCommandModule;

package/src/command-builder/utilities/command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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 { Argv } from 'yargs';
+import { CommandContext, CommandModule, CommandModuleImplementation } from '../command-module';
+export declare const demandCommandFailureMessage = "You need to specify a command before moving on. Use '--help' to view the available commands.";
+export declare function addCommandModuleToYargs<T, U extends Partial<CommandModuleImplementation> & {
+    new (context: CommandContext): Partial<CommandModuleImplementation> & CommandModule;
+}>(localYargs: Argv<T>, commandModule: U, context: CommandContext): Argv<T>;