nx 13.8.8 → 13.9.0-beta.2

package/src/commands/ngcli-adapter.js

@@ -0,0 +1,940 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = exports.invokeNew = exports.wrapAngularDevkitSchematic = exports.mockSchematicsForTesting = exports.overrideCollectionResolutionForTesting = exports.runMigration = exports.generate = exports.NxScopeHostUsedForWrappedSchematics = exports.NxScopedHostForMigrations = exports.NxScopedHost = exports.scheduleTarget = void 0;
+const tslib_1 = require("tslib");
+/* eslint-disable no-restricted-imports */
+const core_1 = require("@angular-devkit/core");
+const chalk = require("chalk");
+const node_1 = require("@angular-devkit/core/node");
+const package_manager_1 = require("../shared/package-manager");
+const workspace_1 = require("../shared/workspace");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const logger_1 = require("../shared/logger");
+const fileutils_1 = require("../utils/fileutils");
+const json_1 = require("../utils/json");
+function scheduleTarget(root, opts, verbose) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const { Architect } = require('@angular-devkit/architect');
+        const { WorkspaceNodeModulesArchitectHost, } = require('@angular-devkit/architect/node');
+        const logger = getTargetLogger(opts.executor, verbose);
+        const fsHost = new NxScopedHost((0, core_1.normalize)(root));
+        const { workspace } = yield core_1.workspaces.readWorkspace((0, workspace_1.workspaceConfigName)(root), core_1.workspaces.createWorkspaceHost(fsHost));
+        const registry = new core_1.schema.CoreSchemaRegistry();
+        registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+        const architectHost = new WorkspaceNodeModulesArchitectHost(workspace, root);
+        const architect = new Architect(architectHost, registry);
+        const run = yield architect.scheduleTarget({
+            project: opts.project,
+            target: opts.target,
+            configuration: opts.configuration,
+        }, opts.runOptions, { logger });
+        let lastOutputError;
+        return run.output.pipe((0, operators_1.tap)((output) => (lastOutputError = !output.success ? output.error : undefined), (error) => { }, // do nothing, this could be an intentional error
+        () => {
+            lastOutputError ? logger.error(lastOutputError) : 0;
+        }));
+    });
+}
+exports.scheduleTarget = scheduleTarget;
+function createWorkflow(fsHost, root, opts) {
+    const NodeWorkflow = require('@angular-devkit/schematics/tools').NodeWorkflow;
+    const workflow = new NodeWorkflow(fsHost, {
+        force: opts.force,
+        dryRun: opts.dryRun,
+        packageManager: (0, package_manager_1.detectPackageManager)(),
+        root: (0, core_1.normalize)(root),
+        registry: new core_1.schema.CoreSchemaRegistry(require('@angular-devkit/schematics').formats.standardFormats),
+        resolvePaths: [process.cwd(), root],
+    });
+    workflow.registry.addPostTransform(core_1.schema.transforms.addUndefinedDefaults);
+    workflow.engineHost.registerOptionsTransform(require('@angular-devkit/schematics/tools').validateOptionsWithSchema(workflow.registry));
+    if (opts.interactive) {
+        workflow.registry.usePromptProvider(createPromptProvider());
+    }
+    return workflow;
+}
+function getCollection(workflow, name) {
+    const collection = workflow.engine.createCollection(name);
+    if (!collection)
+        throw new Error(`Cannot find collection '${name}'`);
+    return collection;
+}
+function createRecorder(host, record, logger) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const actualConfigName = yield host.workspaceConfigName();
+        return (event) => {
+            let eventPath = event.path.startsWith('/')
+                ? event.path.substr(1)
+                : event.path;
+            if (eventPath === 'workspace.json' || eventPath === 'angular.json') {
+                eventPath = actualConfigName;
+            }
+            if (event.kind === 'error') {
+                record.error = true;
+                logger.warn(`ERROR! ${eventPath} ${event.description == 'alreadyExist'
+                    ? 'already exists'
+                    : 'does not exist.'}.`);
+            }
+            else if (event.kind === 'update') {
+                record.loggingQueue.push(core_1.tags.oneLine `${chalk.white('UPDATE')} ${eventPath}`);
+            }
+            else if (event.kind === 'create') {
+                record.loggingQueue.push(core_1.tags.oneLine `${chalk.green('CREATE')} ${eventPath}`);
+            }
+            else if (event.kind === 'delete') {
+                record.loggingQueue.push(`${chalk.yellow('DELETE')} ${eventPath}`);
+            }
+            else if (event.kind === 'rename') {
+                record.loggingQueue.push(`${chalk.blue('RENAME')} ${eventPath} => ${event.to}`);
+            }
+        };
+    });
+}
+function runSchematic(host, root, workflow, logger, opts, schematic, printDryRunMessage = true, recorder = null) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const record = { loggingQueue: [], error: false };
+        workflow.reporter.subscribe(recorder || (yield createRecorder(host, record, logger)));
+        try {
+            yield workflow
+                .execute({
+                collection: opts.collectionName,
+                schematic: opts.generatorName,
+                options: opts.generatorOptions,
+                debug: opts.debug,
+                logger,
+            })
+                .toPromise();
+        }
+        catch (e) {
+            console.log(e);
+            throw e;
+        }
+        if (!record.error) {
+            record.loggingQueue.forEach((log) => logger.info(log));
+        }
+        if (opts.dryRun && printDryRunMessage) {
+            logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
+        }
+        return { status: 0, loggingQueue: record.loggingQueue };
+    });
+}
+class NxScopedHost extends core_1.virtualFs.ScopedHost {
+    constructor(root) {
+        super(new node_1.NodeJsSyncHost(), root);
+        this.__readWorkspaceConfiguration = (configFileName, overrides) => {
+            const readJsonFile = (path) => super
+                .read(path)
+                .pipe((0, operators_1.map)((data) => JSON.parse(Buffer.from(data).toString())));
+            const readWorkspaceJsonFile = (nxJson) => {
+                if (overrides === null || overrides === void 0 ? void 0 : overrides.workspace) {
+                    return overrides.workspace;
+                }
+                else if (this.__nxInMemoryWorkspace) {
+                    return (0, rxjs_1.of)(this.__nxInMemoryWorkspace);
+                }
+                else {
+                    if (configFileName) {
+                        return super
+                            .read(configFileName)
+                            .pipe((0, operators_1.map)((data) => (0, json_1.parseJson)(Buffer.from(data).toString())));
+                    }
+                    else {
+                        const staticProjects = (0, workspace_1.globForProjectFiles)(this._root);
+                        this.__nxInMemoryWorkspace = (0, workspace_1.buildWorkspaceConfigurationFromGlobs)(nxJson, staticProjects.filter((x) => (0, path_1.basename)(x) !== 'package.json'));
+                        Object.entries(this.__nxInMemoryWorkspace.projects).forEach(([project, config]) => {
+                            this.__nxInMemoryWorkspace.projects[project] = config.root;
+                        });
+                        return (0, rxjs_1.of)(this.__nxInMemoryWorkspace);
+                    }
+                }
+            };
+            const readNxJsonFile = () => {
+                if (overrides === null || overrides === void 0 ? void 0 : overrides.nx) {
+                    return overrides.nx;
+                }
+                return readJsonFile('nx.json');
+            };
+            return super.exists('nx.json').pipe((0, operators_1.switchMap)((nxJsonExists) => {
+                let nxJsonObservable = rxjs_1.NEVER;
+                if (nxJsonExists) {
+                    nxJsonObservable = readNxJsonFile();
+                }
+                else {
+                    nxJsonObservable = (0, rxjs_1.of)({});
+                }
+                const workspaceJsonObservable = nxJsonObservable.pipe((0, operators_1.switchMap)((x) => readWorkspaceJsonFile(x)));
+                return (0, rxjs_1.forkJoin)([nxJsonObservable, workspaceJsonObservable]);
+            }), (0, operators_1.switchMap)(([nxJson, workspaceJson]) => {
+                try {
+                    // resolve inline configurations and downlevel format
+                    return this.resolveInlineProjectConfigurations(workspaceJson).pipe((0, operators_1.map)((x) => {
+                        var _a, _b, _c;
+                        const angularJson = x;
+                        // assign props ng cli expects from nx json, if it exists
+                        (_a = angularJson.cli) !== null && _a !== void 0 ? _a : (angularJson.cli = nxJson === null || nxJson === void 0 ? void 0 : nxJson.cli);
+                        (_b = angularJson.generators) !== null && _b !== void 0 ? _b : (angularJson.generators = nxJson === null || nxJson === void 0 ? void 0 : nxJson.generators);
+                        (_c = angularJson.defaultProject) !== null && _c !== void 0 ? _c : (angularJson.defaultProject = nxJson === null || nxJson === void 0 ? void 0 : nxJson.defaultProject);
+                        if (workspaceJson.version === 2) {
+                            const formatted = (0, workspace_1.toOldFormatOrNull)(workspaceJson);
+                            return formatted
+                                ? Buffer.from((0, json_1.serializeJson)(formatted))
+                                : Buffer.from((0, json_1.serializeJson)(x));
+                        }
+                        return Buffer.from((0, json_1.serializeJson)(x));
+                    }));
+                }
+                catch (_a) {
+                    return (0, rxjs_1.of)(Buffer.from((0, json_1.serializeJson)(workspaceJson)));
+                }
+            }));
+        };
+    }
+    read(path) {
+        return this.context(path).pipe((0, operators_1.switchMap)((r) => {
+            if (r.isWorkspaceConfig) {
+                return this.__readWorkspaceConfiguration(r.actualConfigFileName);
+            }
+            else {
+                return super.read(path);
+            }
+        }));
+    }
+    write(path, content) {
+        return this.context(path).pipe((0, operators_1.switchMap)((r) => {
+            if (r.isWorkspaceConfig) {
+                return this.writeWorkspaceConfiguration(r, content);
+            }
+            else {
+                return super.write(path, content);
+            }
+        }));
+    }
+    isFile(path) {
+        return this.context(path).pipe((0, operators_1.switchMap)((r) => {
+            if (r.isWorkspaceConfig) {
+                return (0, rxjs_1.of)(true); // isWorkspaceConfig means its a file
+            }
+            else {
+                return super.isFile(path);
+            }
+        }));
+    }
+    exists(path) {
+        return this.context(path).pipe((0, operators_1.switchMap)((r) => {
+            if (r.isWorkspaceConfig) {
+                return (0, rxjs_1.of)(true);
+            }
+            else {
+                return super.exists(path);
+            }
+        }));
+    }
+    workspaceConfigName() {
+        return super
+            .exists('/angular.json')
+            .pipe((0, operators_1.map)((hasAngularJson) => hasAngularJson ? 'angular.json' : 'workspace.json'))
+            .toPromise();
+    }
+    context(path) {
+        if (isWorkspaceConfigPath(path)) {
+            return (0, rxjs_1.forkJoin)([
+                super.exists('/angular.json'),
+                super.exists('/workspace.json'),
+            ]).pipe((0, operators_1.switchMap)(([isAngularJson, isWorkspaceJson]) => {
+                if (!isAngularJson && !isWorkspaceJson) {
+                    return (0, rxjs_1.of)({
+                        isWorkspaceConfig: true,
+                        actualConfigFileName: null,
+                        // AngularJson / WorkspaceJson v2 is always used for standalone project config
+                        isNewFormat: true,
+                    });
+                }
+                const actualConfigFileName = isAngularJson
+                    ? '/angular.json'
+                    : '/workspace.json';
+                return super.read(actualConfigFileName).pipe((0, operators_1.map)((r) => {
+                    try {
+                        const w = (0, json_1.parseJson)(Buffer.from(r).toString());
+                        return {
+                            isWorkspaceConfig: true,
+                            actualConfigFileName,
+                            isNewFormat: w.version === 2,
+                        };
+                    }
+                    catch (_a) {
+                        return {
+                            isWorkspaceConfig: true,
+                            actualConfigFileName,
+                            isNewFormat: false,
+                        };
+                    }
+                }));
+            }));
+        }
+        else {
+            return (0, rxjs_1.of)({
+                isWorkspaceConfig: false,
+                actualConfigFileName: null,
+                isNewFormat: false,
+            });
+        }
+    }
+    writeWorkspaceConfiguration(context, content) {
+        const config = (0, json_1.parseJson)(Buffer.from(content).toString());
+        if (context.isNewFormat) {
+            try {
+                const w = (0, json_1.parseJson)(Buffer.from(content).toString());
+                const formatted = (0, workspace_1.toNewFormatOrNull)(w);
+                if (formatted) {
+                    const { cli, generators, defaultProject } = formatted, workspaceJson = (0, tslib_1.__rest)(formatted, ["cli", "generators", "defaultProject"]);
+                    return (0, rxjs_1.merge)(this.writeWorkspaceConfigFiles(context, workspaceJson), cli || generators || defaultProject
+                        ? this.__saveNxJsonProps({ cli, generators, defaultProject })
+                        : (0, rxjs_1.of)(null));
+                }
+                else {
+                    const { cli, schematics, generators, defaultProject } = w, angularJson = (0, tslib_1.__rest)(w, ["cli", "schematics", "generators", "defaultProject"]);
+                    return (0, rxjs_1.merge)(this.writeWorkspaceConfigFiles(context, angularJson), cli || schematics
+                        ? this.__saveNxJsonProps({
+                            cli,
+                            defaultProject,
+                            generators: schematics || generators,
+                        })
+                        : (0, rxjs_1.of)(null));
+                }
+            }
+            catch (e) { }
+        }
+        const { cli, schematics, generators, defaultProject } = config, angularJson = (0, tslib_1.__rest)(config, ["cli", "schematics", "generators", "defaultProject"]);
+        return (0, rxjs_1.merge)(this.writeWorkspaceConfigFiles(context, angularJson), this.__saveNxJsonProps({
+            cli,
+            defaultProject,
+            generators: schematics || generators,
+        }));
+    }
+    __saveNxJsonProps(props) {
+        const nxJsonPath = 'nx.json';
+        return super.read(nxJsonPath).pipe((0, operators_1.switchMap)((buf) => {
+            const nxJson = (0, json_1.parseJson)(Buffer.from(buf).toString());
+            Object.assign(nxJson, props);
+            return super.write(nxJsonPath, Buffer.from((0, json_1.serializeJson)(nxJson)));
+        }));
+    }
+    writeWorkspaceConfigFiles({ actualConfigFileName: workspaceFileName, isNewFormat }, config) {
+        // copy to avoid removing inlined config files.
+        const writeObservables = [];
+        const configToWrite = Object.assign(Object.assign({}, config), { projects: Object.assign({}, config.projects) });
+        const projects = Object.entries(configToWrite.projects);
+        for (const [project, projectConfig] of projects) {
+            if (projectConfig.configFilePath) {
+                if (workspaceFileName && !isNewFormat) {
+                    throw new Error('Attempted to write standalone project configuration into a v1 workspace');
+                }
+                // project was read from a project.json file
+                const configPath = projectConfig.configFilePath;
+                const fileConfigObject = Object.assign({}, projectConfig);
+                delete fileConfigObject.configFilePath; // remove the configFilePath before writing
+                const projectJsonWrite = super.write(configPath, Buffer.from((0, json_1.serializeJson)(fileConfigObject))); // write back to the project.json file
+                writeObservables.push(projectJsonWrite);
+                configToWrite.projects[project] = (0, core_1.normalize)((0, path_1.dirname)(configPath)); // update the config object to point to the written file.
+            }
+        }
+        if (workspaceFileName) {
+            const workspaceJsonWrite = super.write(workspaceFileName, Buffer.from((0, json_1.serializeJson)(configToWrite)));
+            writeObservables.push(workspaceJsonWrite);
+        }
+        return (0, rxjs_1.merge)(...writeObservables);
+    }
+    resolveInlineProjectConfigurations(config) {
+        var _a;
+        // Creates an observable where each emission is a project configuration
+        // that is not listed inside workspace.json. Each time it encounters a
+        // standalone config, observable is updated by concatenating the new
+        // config read operation.
+        const observables = [];
+        Object.entries((_a = config.projects) !== null && _a !== void 0 ? _a : {}).forEach(([project, projectConfig]) => {
+            if (typeof projectConfig === 'string') {
+                // configFilePath is not written to files, but is stored on the config object
+                // so that we know where to save the project's configuration if it was updated
+                // by another angular schematic.
+                const configFilePath = (0, path_1.join)(projectConfig, 'project.json');
+                const next = this.read(configFilePath).pipe((0, operators_1.map)((x) => ({
+                    project,
+                    projectConfig: Object.assign(Object.assign({}, (0, json_1.parseJson)(Buffer.from(x).toString())), { configFilePath }),
+                })));
+                observables.push(next);
+            }
+        });
+        return (0, rxjs_1.merge)(...observables).pipe((0, operators_1.toArray)(), (0, operators_1.map)((configs) => {
+            configs.forEach(({ project, projectConfig }) => {
+                config.projects[project] = projectConfig;
+            });
+            return config;
+        }));
+    }
+}
+exports.NxScopedHost = NxScopedHost;
+/**
+ * This host contains the workaround needed to run Angular migrations
+ */
+class NxScopedHostForMigrations extends NxScopedHost {
+    constructor(root) {
+        super(root);
+    }
+    read(path) {
+        if (isWorkspaceConfigPath(path)) {
+            return super.read(path).pipe((0, operators_1.map)(processConfigWhenReading));
+        }
+        else {
+            return super.read(path);
+        }
+    }
+    write(path, content) {
+        if (isWorkspaceConfigPath(path)) {
+            return super.write(path, processConfigWhenWriting(content));
+        }
+        else {
+            return super.write(path, content);
+        }
+    }
+}
+exports.NxScopedHostForMigrations = NxScopedHostForMigrations;
+class NxScopeHostUsedForWrappedSchematics extends NxScopedHost {
+    constructor(root, host) {
+        super(root);
+        this.host = host;
+    }
+    read(path) {
+        if (isWorkspaceConfigPath(path)) {
+            const nxJsonChange = findMatchingFileChange(this.host, 'nx.json');
+            const match = findWorkspaceConfigFileChange(this.host);
+            let workspaceJsonOverride;
+            let actualConfigFileName = [
+                '/workspace.json',
+                '/angular.json',
+            ].filter((f) => this.host.exists(f))[0];
+            if (actualConfigFileName) {
+                if (match) {
+                    workspaceJsonOverride = (0, rxjs_1.of)((0, json_1.parseJson)(match.content.toString()));
+                }
+            }
+            else if (!this.__nxInMemoryWorkspace) {
+                // if we've already dealt with this, let NxScopedHost read the cache...
+                // projects created inside a generator will not be visible
+                // to glob when it runs in nx/shared/workspace, so
+                // we have to add them into the file.
+                const createdProjectFiles = findCreatedProjects(this.host);
+                const deletedProjectFiles = findDeletedProjects(this.host);
+                const nxJsonInTree = nxJsonChange
+                    ? (0, json_1.parseJson)(nxJsonChange.content.toString())
+                    : (0, json_1.parseJson)(this.host.read('nx.json').toString());
+                const readJsonWithHost = (file) => (0, json_1.parseJson)(this.host.read(file).toString());
+                const staticProjects = (0, workspace_1.buildWorkspaceConfigurationFromGlobs)(nxJsonInTree, (0, workspace_1.globForProjectFiles)(this.host.root).filter((x) => (0, path_1.basename)(x) !== 'package.json'), readJsonWithHost);
+                const createdProjects = (0, workspace_1.buildWorkspaceConfigurationFromGlobs)(nxJsonInTree, createdProjectFiles.map((x) => x.path), readJsonWithHost).projects;
+                deletedProjectFiles.forEach((file) => {
+                    const matchingStaticProject = Object.entries(staticProjects.projects).find(([, config]) => config.root === (0, path_1.dirname)(file.path));
+                    if (matchingStaticProject) {
+                        delete staticProjects.projects[matchingStaticProject[0]];
+                    }
+                });
+                const workspace = Object.assign(Object.assign({}, staticProjects), { projects: Object.assign(Object.assign({}, staticProjects.projects), createdProjects) });
+                workspaceJsonOverride = (0, rxjs_1.of)(Object.assign(Object.assign({}, workspace), { 
+                    // all projects **must** be standalone if workspace.json doesn't exist
+                    // since the NxScopedHost already handles the standalone config case,
+                    // lets pass them as standalone.
+                    projects: Object.fromEntries(Object.entries(workspace.projects).map(([project, config]) => [
+                        project,
+                        config.root,
+                    ])) }));
+            }
+            // no match, default to existing behavior
+            if (!workspaceJsonOverride && !nxJsonChange) {
+                return super.read(path);
+            }
+            // we try to format it, if it changes, return it, otherwise return the original change
+            try {
+                return this.__readWorkspaceConfiguration(actualConfigFileName, {
+                    // we are overriding workspaceJson + nxJson,
+                    workspace: workspaceJsonOverride,
+                    nx: nxJsonChange
+                        ? (0, rxjs_1.of)((0, json_1.parseJson)(nxJsonChange.content.toString()))
+                        : null,
+                });
+            }
+            catch (e) {
+                return super.read(path);
+            }
+        }
+        else {
+            const match = findMatchingFileChange(this.host, path);
+            if (match) {
+                // found a matching change in the host
+                return (0, rxjs_1.of)(Buffer.from(match.content));
+            }
+            else if (
+            // found a change to workspace config, and reading a project config file
+            (0, path_1.basename)(path) === 'project.json' &&
+                findWorkspaceConfigFileChange(this.host)) {
+                return (0, rxjs_1.of)(this.host.read(path));
+            }
+            else {
+                // found neither, use default read method
+                return super.read(path);
+            }
+        }
+    }
+    exists(path) {
+        if (isWorkspaceConfigPath(path)) {
+            return findWorkspaceConfigFileChange(this.host)
+                ? (0, rxjs_1.of)(true)
+                : super.exists(path);
+        }
+        else {
+            return findMatchingFileChange(this.host, path)
+                ? (0, rxjs_1.of)(true)
+                : super.exists(path);
+        }
+    }
+    isDirectory(path) {
+        return super.isDirectory(path).pipe((0, operators_1.catchError)(() => (0, rxjs_1.of)(false)), (0, operators_1.switchMap)((isDirectory) => isDirectory
+            ? (0, rxjs_1.of)(true)
+            : (0, rxjs_1.of)(this.host.exists(path) && !this.host.isFile(path))));
+    }
+    isFile(path) {
+        if (isWorkspaceConfigPath(path)) {
+            return findWorkspaceConfigFileChange(this.host)
+                ? (0, rxjs_1.of)(true)
+                : super.isFile(path);
+        }
+        else {
+            return findMatchingFileChange(this.host, path)
+                ? (0, rxjs_1.of)(true)
+                : super.isFile(path);
+        }
+    }
+    list(path) {
+        const fragments = this.host.children(path).map((child) => (0, core_1.fragment)(child));
+        return (0, rxjs_1.of)(fragments);
+    }
+}
+exports.NxScopeHostUsedForWrappedSchematics = NxScopeHostUsedForWrappedSchematics;
+function findWorkspaceConfigFileChange(host) {
+    return host
+        .listChanges()
+        .find((f) => f.path == 'workspace.json' || f.path == 'angular.json');
+}
+function findCreatedProjects(host) {
+    return host
+        .listChanges()
+        .filter((f) => ((0, path_1.basename)(f.path) === 'project.json' ||
+        (0, path_1.basename)(f.path) === 'package.json') &&
+        f.type === 'CREATE');
+}
+function findDeletedProjects(host) {
+    return host
+        .listChanges()
+        .filter((f) => (0, path_1.basename)(f.path) === 'project.json' && f.type === 'DELETE');
+}
+function findMatchingFileChange(host, path) {
+    const targetPath = path.startsWith('/') ? path.substring(1) : path.toString();
+    return host
+        .listChanges()
+        .find((f) => f.path === targetPath && f.type !== 'DELETE');
+}
+function isWorkspaceConfigPath(p) {
+    return (p === 'angular.json' ||
+        p === '/angular.json' ||
+        p === 'workspace.json' ||
+        p === '/workspace.json');
+}
+function processConfigWhenReading(content) {
+    try {
+        const json = (0, json_1.parseJson)(Buffer.from(content).toString());
+        Object.values(json.projects).forEach((p) => {
+            try {
+                Object.values(p.architect || p.targets).forEach((e) => {
+                    if ((e.builder === '@nrwl/jest:jest' ||
+                        e.executor === '@nrwl/jest:jest') &&
+                        !e.options.tsConfig) {
+                        e.options.tsConfig = `${p.root}/tsconfig.spec.json`;
+                    }
+                });
+            }
+            catch (e) { }
+        });
+        return Buffer.from((0, json_1.serializeJson)(json));
+    }
+    catch (e) {
+        return content;
+    }
+}
+function processConfigWhenWriting(content) {
+    try {
+        const json = (0, json_1.parseJson)(Buffer.from(content).toString());
+        Object.values(json.projects).forEach((p) => {
+            try {
+                Object.values(p.architect || p.targets).forEach((e) => {
+                    if ((e.builder === '@nrwl/jest:jest' ||
+                        e.executor === '@nrwl/jest:jest') &&
+                        e.options.tsConfig) {
+                        delete e.options.tsConfig;
+                    }
+                });
+            }
+            catch (e) { }
+        });
+        return Buffer.from((0, json_1.serializeJson)(json));
+    }
+    catch (e) {
+        return content;
+    }
+}
+function generate(root, opts, verbose) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const logger = (0, exports.getLogger)(verbose);
+        const fsHost = new NxScopedHost((0, core_1.normalize)(root));
+        const workflow = createWorkflow(fsHost, root, opts);
+        const collection = getCollection(workflow, opts.collectionName);
+        const schematic = collection.createSchematic(opts.generatorName, true);
+        return (yield runSchematic(fsHost, root, workflow, logger, Object.assign(Object.assign({}, opts), { generatorName: schematic.description.name }), schematic)).status;
+    });
+}
+exports.generate = generate;
+function createPromptProvider() {
+    return (definitions) => {
+        const questions = definitions.map((definition) => {
+            const question = {
+                name: definition.id,
+                message: definition.message,
+            };
+            if (definition.default) {
+                question.initial = definition.default;
+            }
+            const validator = definition.validator;
+            if (validator) {
+                question.validate = (input) => validator(input);
+            }
+            switch (definition.type) {
+                case 'string':
+                case 'input':
+                    return Object.assign(Object.assign({}, question), { type: 'input' });
+                case 'boolean':
+                case 'confirmation':
+                case 'confirm':
+                    return Object.assign(Object.assign({}, question), { type: 'confirm' });
+                case 'number':
+                case 'numeral':
+                    return Object.assign(Object.assign({}, question), { type: 'numeral' });
+                case 'list':
+                    return Object.assign(Object.assign({}, question), { type: !!definition.multiselect ? 'multiselect' : 'select', choices: definition.items &&
+                            definition.items.map((item) => {
+                                if (typeof item == 'string') {
+                                    return item;
+                                }
+                                else {
+                                    return {
+                                        message: item.label,
+                                        name: item.value,
+                                    };
+                                }
+                            }) });
+                default:
+                    return Object.assign(Object.assign({}, question), { type: definition.type });
+            }
+        });
+        return require('enquirer').prompt(questions);
+    };
+}
+function runMigration(root, packageName, migrationName, isVerbose) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const logger = (0, exports.getLogger)(isVerbose);
+        const fsHost = new NxScopedHost((0, core_1.normalize)(root));
+        const workflow = createWorkflow(fsHost, root, {});
+        const collection = resolveMigrationsCollection(packageName);
+        return workflow
+            .execute({
+            collection,
+            schematic: migrationName,
+            options: {},
+            debug: false,
+            logger: logger,
+        })
+            .toPromise();
+    });
+}
+exports.runMigration = runMigration;
+function resolveMigrationsCollection(name) {
+    var _a;
+    let collectionPath = undefined;
+    if (name.startsWith('.') || name.startsWith('/')) {
+        name = (0, path_1.resolve)(name);
+    }
+    if ((0, path_1.extname)(name)) {
+        collectionPath = require.resolve(name);
+    }
+    else {
+        let packageJsonPath;
+        try {
+            packageJsonPath = require.resolve((0, path_1.join)(name, 'package.json'), {
+                paths: [process.cwd()],
+            });
+        }
+        catch (e) {
+            // workaround for a bug in node 12
+            packageJsonPath = require.resolve((0, path_1.join)(process.cwd(), name, 'package.json'));
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const packageJson = require(packageJsonPath);
+        let pkgJsonSchematics = (_a = packageJson['nx-migrations']) !== null && _a !== void 0 ? _a : packageJson['ng-update'];
+        if (!pkgJsonSchematics) {
+            throw new Error(`Could not find migrations in package: "${name}"`);
+        }
+        if (typeof pkgJsonSchematics != 'string') {
+            pkgJsonSchematics = pkgJsonSchematics.migrations;
+        }
+        collectionPath = require.resolve(pkgJsonSchematics, {
+            paths: [(0, path_1.dirname)(packageJsonPath)],
+        });
+    }
+    try {
+        if (collectionPath) {
+            (0, fileutils_1.readJsonFile)(collectionPath);
+            return collectionPath;
+        }
+    }
+    catch (_b) {
+        throw new Error(`Invalid migration file in package: "${name}"`);
+    }
+    throw new Error(`Collection cannot be resolved: "${name}"`);
+}
+function convertEventTypeToHandleMultipleConfigNames(host, eventPath, content) {
+    const actualConfigName = host.exists('/angular.json')
+        ? 'angular.json'
+        : 'workspace.json';
+    const isWorkspaceConfig = eventPath === 'angular.json' || eventPath === 'workspace.json';
+    if (isWorkspaceConfig) {
+        let isNewFormat = true;
+        try {
+            isNewFormat =
+                (0, json_1.parseJson)(host.read(actualConfigName, 'utf-8')).version === 2;
+        }
+        catch (e) { }
+        if (content && isNewFormat) {
+            const formatted = (0, workspace_1.toNewFormat)((0, json_1.parseJson)(content.toString()));
+            if (formatted) {
+                return {
+                    eventPath: actualConfigName,
+                    content: Buffer.from((0, json_1.serializeJson)(formatted)),
+                };
+            }
+            else {
+                return { eventPath: actualConfigName, content };
+            }
+        }
+        else {
+            return { eventPath: actualConfigName, content };
+        }
+    }
+    else {
+        return { eventPath, content };
+    }
+}
+let collectionResolutionOverrides = null;
+let mockedSchematics = null;
+/**
+ * By default, Angular Devkit schematic collections will be resolved using the Node resolution.
+ * This doesn't work if you are testing schematics that refer to other schematics in the
+ * same repo.
+ *
+ * This function can can be used to override the resolution behaviour.
+ *
+ * Example:
+ *
+ * ```typescript
+ *   overrideCollectionResolutionForTesting({
+ *     '@nrwl/workspace': path.join(__dirname, '../../../../workspace/generators.json'),
+ *     '@nrwl/angular': path.join(__dirname, '../../../../angular/generators.json'),
+ *     '@nrwl/linter': path.join(__dirname, '../../../../linter/generators.json')
+ *   });
+ *
+ * ```
+ */
+function overrideCollectionResolutionForTesting(collections) {
+    collectionResolutionOverrides = collections;
+}
+exports.overrideCollectionResolutionForTesting = overrideCollectionResolutionForTesting;
+/**
+ * If you have an Nx Devkit generator invoking the wrapped Angular Devkit schematic,
+ * and you don't want the Angular Devkit schematic to run, you can mock it up using this function.
+ *
+ * Unfortunately, there are some edge cases in the Nx-Angular devkit integration that
+ * can be seen in the unit tests context. This function is useful for handling that as well.
+ *
+ * In this case, you can mock it up.
+ *
+ * Example:
+ *
+ * ```typescript
+ *   mockSchematicsForTesting({
+ *     'mycollection:myschematic': (tree, params) => {
+ *        tree.write('README.md');
+ *     }
+ *   });
+ *
+ * ```
+ */
+function mockSchematicsForTesting(schematics) {
+    mockedSchematics = schematics;
+}
+exports.mockSchematicsForTesting = mockSchematicsForTesting;
+function wrapAngularDevkitSchematic(collectionName, generatorName) {
+    return (host, generatorOptions) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        if (mockedSchematics &&
+            mockedSchematics[`${collectionName}:${generatorName}`]) {
+            return yield mockedSchematics[`${collectionName}:${generatorName}`](host, generatorOptions);
+        }
+        const emptyLogger = {
+            log: (e) => { },
+            info: (e) => { },
+            warn: (e) => { },
+            debug: () => { },
+            error: (e) => { },
+            fatal: (e) => { },
+        };
+        emptyLogger.createChild = () => emptyLogger;
+        const recorder = (event) => {
+            let eventPath = event.path.startsWith('/')
+                ? event.path.substr(1)
+                : event.path;
+            const r = convertEventTypeToHandleMultipleConfigNames(host, eventPath, event.content);
+            if (event.kind === 'error') {
+            }
+            else if (event.kind === 'update') {
+                if (r.eventPath === 'angular.json' ||
+                    r.eventPath === 'workspace.json') {
+                    saveWorkspaceConfigurationInWrappedSchematic(host, r);
+                }
+                else {
+                    host.write(r.eventPath, r.content);
+                }
+            }
+            else if (event.kind === 'create') {
+                host.write(r.eventPath, r.content);
+            }
+            else if (event.kind === 'delete') {
+                host.delete(r.eventPath);
+            }
+            else if (event.kind === 'rename') {
+                host.rename(r.eventPath, event.to);
+            }
+        };
+        const fsHost = new NxScopeHostUsedForWrappedSchematics((0, core_1.normalize)(host.root), host);
+        const options = {
+            generatorOptions,
+            dryRun: true,
+            interactive: false,
+            help: false,
+            debug: false,
+            collectionName,
+            generatorName,
+            force: false,
+            defaults: false,
+        };
+        const workflow = createWorkflow(fsHost, host.root, options);
+        // used for testing
+        if (collectionResolutionOverrides) {
+            const r = workflow.engineHost.resolve;
+            workflow.engineHost.resolve = (collection, b, c) => {
+                if (collectionResolutionOverrides[collection]) {
+                    return collectionResolutionOverrides[collection];
+                }
+                else {
+                    return r.apply(workflow.engineHost, [collection, b, c]);
+                }
+            };
+        }
+        const collection = getCollection(workflow, collectionName);
+        const schematic = collection.createSchematic(generatorName, true);
+        const res = yield runSchematic(fsHost, host.root, workflow, emptyLogger, options, schematic, false, recorder);
+        if (res.status !== 0) {
+            throw new Error(res.loggingQueue.join('\n'));
+        }
+    });
+}
+exports.wrapAngularDevkitSchematic = wrapAngularDevkitSchematic;
+function invokeNew(root, opts, verbose) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
+        const logger = (0, exports.getLogger)(verbose);
+        const fsHost = new NxScopedHost((0, core_1.normalize)(root));
+        const workflow = createWorkflow(fsHost, root, opts);
+        const collection = getCollection(workflow, opts.collectionName);
+        const schematic = collection.createSchematic('new', true);
+        return (yield runSchematic(fsHost, root, workflow, logger, Object.assign(Object.assign({}, opts), { generatorName: schematic.description.name }), schematic)).status;
+    });
+}
+exports.invokeNew = invokeNew;
+let logger;
+const loggerColors = {
+    warn: (s) => chalk.bold(chalk.yellow(s)),
+    error: (s) => {
+        if (s.startsWith('NX ')) {
+            return `\n${logger_1.NX_ERROR} ${chalk.bold(chalk.red(s.substr(3)))}\n`;
+        }
+        return chalk.bold(chalk.red(s));
+    },
+    info: (s) => {
+        if (s.startsWith('NX ')) {
+            return `\n${logger_1.NX_PREFIX} ${chalk.bold(s.substr(3))}\n`;
+        }
+        return chalk.white(s);
+    },
+};
+const getLogger = (isVerbose = false) => {
+    if (!logger) {
+        logger = (0, node_1.createConsoleLogger)(isVerbose, process.stdout, process.stderr, loggerColors);
+    }
+    return logger;
+};
+exports.getLogger = getLogger;
+const getTargetLogger = (executor, isVerbose = false) => {
+    if (executor !== '@angular-devkit/build-angular:tslint') {
+        return (0, exports.getLogger)(isVerbose);
+    }
+    const tslintExecutorLogger = (0, node_1.createConsoleLogger)(isVerbose, process.stdout, process.stderr, Object.assign(Object.assign({}, loggerColors), { warn: (s) => {
+            if (s.startsWith(`TSLint's support is discontinued and we're deprecating its support in Angular CLI.`)) {
+                s =
+                    `TSLint's support is discontinued and the @angular-devkit/build-angular:tslint executor is deprecated.\n` +
+                        'To start using a modern linter tool, please consider replacing TSLint with ESLint. ' +
+                        'You can use the "@nrwl/angular:convert-tslint-to-eslint" generator to automatically convert your projects.\n' +
+                        'For more info, visit https://nx.dev/latest/angular/angular/convert-tslint-to-eslint.';
+            }
+            return chalk.bold(chalk.yellow(s));
+        } }));
+    return tslintExecutorLogger;
+};
+function saveWorkspaceConfigurationInWrappedSchematic(host, r) {
+    const workspaceJsonExists = host.exists(r.eventPath);
+    const workspace = (0, json_1.parseJson)(r.content.toString());
+    for (const [project, config] of Object.entries(workspace.projects)) {
+        if (typeof config === 'object' &&
+            (!workspaceJsonExists || config.configFilePath)) {
+            const path = config.configFilePath || (0, path_1.join)(config.root, 'project.json');
+            workspace.projects[project] = (0, core_1.normalize)((0, path_1.dirname)(path));
+            delete config.configFilePath;
+            host.write(path, (0, json_1.serializeJson)(config));
+        }
+    }
+    const nxJson = (0, json_1.parseJson)(host.read('nx.json').toString());
+    nxJson.generators = workspace.generators || workspace.schematics;
+    nxJson.cli = workspace.cli || nxJson.cli;
+    nxJson.defaultProject = workspace.defaultProject;
+    delete workspace.cli;
+    delete workspace.generators;
+    delete workspace.schematics;
+    if (workspaceJsonExists) {
+        r.content = Buffer.from((0, json_1.serializeJson)(workspace));
+        host.write(r.eventPath, r.content);
+    }
+}
+//# sourceMappingURL=ngcli-adapter.js.map