nx 17.0.3 → 17.0.5

package/src/utils/nx-plugin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregisterPluginTSTranspiler = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = exports.isNxPluginV1 = exports.isNxPluginV2 = exports.loadNxPlugins = exports.loadNxPluginsSync = exports.loadNxPluginAsync = void 0;
+exports.getDefaultPlugins = exports.unregisterPluginTSTranspiler = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = exports.isNxPluginV1 = exports.isNxPluginV2 = exports.ensurePluginIsV2 = exports.loadNxPlugins = exports.loadNxPluginAsync = exports.getPluginPathAndName = exports.nxPluginCache = void 0;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const path = require("path");
@@ -15,18 +15,21 @@ const path_1 = require("./path");
 const path_2 = require("path");
 const installation_directory_1 = require("./installation-directory");
 const typescript_1 = require("../plugins/js/utils/typescript");
-const retrieve_workspace_files_1 = require("../project-graph/utils/retrieve-workspace-files");
+const nx_json_1 = require("../config/nx-json");
 const globs_1 = require("./globs");
 const angular_json_1 = require("../adapter/angular-json");
-const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
+const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
 const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+const package_json_next_to_project_json_1 = require("../plugins/project-json/build-nodes/package-json-next-to-project-json");
+const retrieve_workspace_files_1 = require("../project-graph/utils/retrieve-workspace-files");
+const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
 tslib_1.__exportStar(require("./nx-plugin.deprecated"), exports);
 // Short lived cache (cleared between cmd runs)
 // holding resolved nx plugin objects.
 // Allows loadNxPlugins to be called multiple times w/o
 // executing resolution mulitple times.
-let nxPluginCache = new Map();
-function getPluginPathAndName(moduleName, paths, root) {
+exports.nxPluginCache = new Map();
+function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
     try {
         pluginPath = require.resolve(moduleName, {
@@ -35,7 +38,7 @@ function getPluginPathAndName(moduleName, paths, root) {
     }
     catch (e) {
         if (e.code === 'MODULE_NOT_FOUND') {
-            const plugin = resolveLocalNxPlugin(moduleName, root);
+            const plugin = resolveLocalNxPlugin(moduleName, (0, nx_json_1.readNxJson)(root), projects, root);
             if (plugin) {
                 const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
                 pluginPath = main ? path.join(root, main) : plugin.path;
@@ -62,75 +65,63 @@ function getPluginPathAndName(moduleName, paths, root) {
         : { name: moduleName };
     return { pluginPath, name };
 }
-async function loadNxPluginAsync(pluginConfiguration, paths, root) {
+exports.getPluginPathAndName = getPluginPathAndName;
+async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
     const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
         ? pluginConfiguration
         : { plugin: pluginConfiguration, options: undefined };
-    let pluginModule = nxPluginCache.get(moduleName);
+    let pluginModule = exports.nxPluginCache.get(moduleName);
+    const include = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration.include
+        : undefined;
+    const exclude = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration.exclude
+        : undefined;
     if (pluginModule) {
-        return { plugin: pluginModule, options };
+        return {
+            plugin: pluginModule,
+            options,
+            include,
+            exclude,
+        };
     }
-    let { pluginPath, name } = getPluginPathAndName(moduleName, paths, root);
+    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
     const plugin = ensurePluginIsV2((await Promise.resolve(`${pluginPath}`).then(s => require(s))));
     plugin.name ??= name;
-    nxPluginCache.set(moduleName, plugin);
-    return { plugin, options };
+    exports.nxPluginCache.set(moduleName, plugin);
+    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+    return {
+        plugin,
+        options,
+        include,
+        exclude,
+    };
 }
 exports.loadNxPluginAsync = loadNxPluginAsync;
-function loadNxPluginSync(pluginConfiguration, paths, root) {
-    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration
-        : { plugin: pluginConfiguration, options: undefined };
-    let pluginModule = nxPluginCache.get(moduleName);
-    if (pluginModule) {
-        return { plugin: pluginModule, options };
-    }
-    let { pluginPath, name } = getPluginPathAndName(moduleName, paths, root);
-    const plugin = ensurePluginIsV2(require(pluginPath));
-    plugin.name ??= name;
-    nxPluginCache.set(moduleName, plugin);
-    return { plugin, options };
-}
-/**
- * @deprecated Use loadNxPlugins instead.
- */
-function loadNxPluginsSync(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot) {
-    // TODO: This should be specified in nx.json
-    // Temporarily load js as if it were a plugin which is built into nx
-    // In the future, this will be optional and need to be specified in nx.json
-    const result = [...getDefaultPluginsSync(root)];
-    if ((0, angular_json_1.shouldMergeAngularProjects)(root, false)) {
-        result.push({ plugin: angular_json_1.NxAngularJsonPlugin, options: undefined });
-    }
+async function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot, projects) {
+    const result = [
+        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
+    ];
     plugins ??= [];
+    // When loading plugins for `createNodes`, we don't know what projects exist yet.
+    // Try resolving plugins
     for (const plugin of plugins) {
         try {
-            result.push(loadNxPluginSync(plugin, paths, root));
+            require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
         }
-        catch (e) {
-            if (e.code === 'ERR_REQUIRE_ESM') {
-                throw new Error(`Unable to load "${plugin}". Plugins cannot be ESM modules. They must be CommonJS modules. Follow the issue on github: https://github.com/nrwl/nx/issues/15682`);
-            }
-            throw e;
+        catch {
+            // If a plugin cannot be resolved, we will need projects to resolve it
+            projects ??= await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+            break;
         }
     }
-    // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
-    result.push({ plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) }, { plugin: project_json_1.CreateProjectJsonProjectsPlugin });
-    return result;
-}
-exports.loadNxPluginsSync = loadNxPluginsSync;
-async function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot) {
-    const result = [...(await getDefaultPlugins(root))];
-    // TODO: These should be specified in nx.json
-    // Temporarily load js as if it were a plugin which is built into nx
-    // In the future, this will be optional and need to be specified in nx.json
-    result.push();
-    plugins ??= [];
     for (const plugin of plugins) {
-        result.push(await loadNxPluginAsync(plugin, paths, root));
+        result.push(await loadNxPluginAsync(plugin, paths, projects, root));
     }
     // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
-    result.push({ plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) }, { plugin: project_json_1.CreateProjectJsonProjectsPlugin });
+    result.push(...(await getDefaultPlugins(root)));
     return result;
 }
 exports.loadNxPlugins = loadNxPlugins;
@@ -144,12 +135,12 @@ function ensurePluginIsV2(plugin) {
             createNodes: [
                 `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
                 (configFilePath) => {
-                    const name = (0, workspaces_1.toProjectName)(configFilePath);
+                    const root = (0, path_2.dirname)(configFilePath);
                     return {
                         projects: {
-                            [name]: {
-                                name,
-                                root: (0, path_2.dirname)(configFilePath),
+                            [root]: {
+                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                root,
                                 targets: plugin.registerProjectTargets?.(configFilePath),
                             },
                         },
@@ -160,6 +151,7 @@ function ensurePluginIsV2(plugin) {
     }
     return plugin;
 }
+exports.ensurePluginIsV2 = ensurePluginIsV2;
 function isNxPluginV2(plugin) {
     return 'createNodes' in plugin || 'createDependencies' in plugin;
 }
@@ -168,7 +160,7 @@ function isNxPluginV1(plugin) {
     return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
 }
 exports.isNxPluginV1 = isNxPluginV1;
-function readPluginPackageJson(pluginName, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
         return {
@@ -178,7 +170,8 @@ function readPluginPackageJson(pluginName, paths = (0, installation_directory_1.
     }
     catch (e) {
         if (e.code === 'MODULE_NOT_FOUND') {
-            const localPluginPath = resolveLocalNxPlugin(pluginName);
+            const nxJson = (0, nx_json_1.readNxJson)();
+            const localPluginPath = resolveLocalNxPlugin(pluginName, nxJson, projects);
             if (localPluginPath) {
                 const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
                 return {
@@ -197,8 +190,8 @@ exports.readPluginPackageJson = readPluginPackageJson;
  * @returns The path to the built plugin, or null if it doesn't exist
  */
 const localPluginCache = {};
-function resolveLocalNxPlugin(importPath, root = workspace_root_1.workspaceRoot) {
-    localPluginCache[importPath] ??= lookupLocalPlugin(importPath, root);
+function resolveLocalNxPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
+    localPluginCache[importPath] ??= lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root);
     return localPluginCache[importPath];
 }
 exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
@@ -242,8 +235,7 @@ function unregisterPluginTSTranspiler() {
     }
 }
 exports.unregisterPluginTSTranspiler = unregisterPluginTSTranspiler;
-function lookupLocalPlugin(importPath, root = workspace_root_1.workspaceRoot) {
-    const projects = (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+function lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
     const plugin = findNxProjectForImportPath(importPath, projects, root);
     if (!plugin) {
         return null;
@@ -299,20 +291,19 @@ function readPluginMainFromProjectConfiguration(plugin) {
     return main;
 }
 async function getDefaultPlugins(root) {
-    const plugins = [await Promise.resolve().then(() => require('../plugins/js'))];
-    if ((0, angular_json_1.shouldMergeAngularProjects)(root, false)) {
-        plugins.push(await Promise.resolve().then(() => require('../adapter/angular-json')).then((m) => m.NxAngularJsonPlugin));
-    }
-    return plugins.map((p) => ({
-        plugin: p,
-    }));
-}
-function getDefaultPluginsSync(root) {
-    const plugins = [require('../plugins/js')];
-    if ((0, angular_json_1.shouldMergeAngularProjects)(root, false)) {
-        plugins.push(require('../adapter/angular-json').NxAngularJsonPlugin);
-    }
+    const plugins = [
+        await Promise.resolve().then(() => require('../plugins/js')),
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [
+                await Promise.resolve().then(() => require('../adapter/angular-json')).then((m) => m.NxAngularJsonPlugin),
+            ]
+            : []),
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
+    ];
     return plugins.map((p) => ({
         plugin: p,
     }));
 }
+exports.getDefaultPlugins = getDefaultPlugins;

package/src/utils/output.d.ts

@@ -1,5 +1,5 @@
 import * as chalk from 'chalk';
-import { TaskStatus } from '../tasks-runner/tasks-runner';
+import type { TaskStatus } from '../tasks-runner/tasks-runner';
 export interface CLIErrorMessageConfig {
     title: string;
     bodyLines?: string[];
@@ -19,7 +19,6 @@ export interface CLISuccessMessageConfig {
     bodyLines?: string[];
 }
 declare class CLIOutput {
-    readonly X_PADDING = " ";
     cliName: string;
     formatCommand: (taskId: string) => string;
     /**
@@ -58,6 +57,9 @@ declare class CLIOutput {
     success({ title, bodyLines }: CLISuccessMessageConfig): void;
     logSingleLine(message: string): void;
     logCommand(message: string, taskStatus?: TaskStatus): void;
+    logCommandOutput(message: string, taskStatus: TaskStatus, output: string): void;
+    private getCommandWithStatus;
+    private getStatusIcon;
     private normalizeMessage;
     private addTaskStatus;
     log({ title, bodyLines, color }: CLIWarnMessageConfig & {

package/src/utils/output.js

@@ -5,6 +5,8 @@ const chalk = require("chalk");
 const os_1 = require("os");
 const readline = require("readline");
 const is_ci_1 = require("./is-ci");
+const GH_GROUP_PREFIX = '::group::';
+const GH_GROUP_SUFFIX = '::endgroup::';
 /**
  * Automatically disable styling applied by chalk if CI=true
  */
@@ -14,7 +16,6 @@ if ((0, is_ci_1.isCI)() && !forceColor) {
 }
 class CLIOutput {
     constructor() {
-        this.X_PADDING = ' ';
         this.cliName = 'NX';
         this.formatCommand = (taskId) => `${chalk.dim('nx run')} ${taskId}`;
         /**
@@ -39,7 +40,7 @@ class CLIOutput {
      */
     get VERTICAL_SEPARATOR() {
         let divider = '';
-        for (let i = 0; i < process.stdout.columns - this.X_PADDING.length * 2; i++) {
+        for (let i = 0; i < process.stdout.columns - 1; i++) {
             divider += '\u2014';
         }
         return divider;
@@ -56,22 +57,22 @@ class CLIOutput {
         process.stdout.write(os_1.EOL);
     }
     writeOutputTitle({ color, title, }) {
-        this.writeToStdOut(` ${this.applyNxPrefix(color, title)}${os_1.EOL}`);
+        this.writeToStdOut(`${this.applyNxPrefix(color, title)}${os_1.EOL}`);
     }
     writeOptionalOutputBody(bodyLines) {
         if (!bodyLines) {
             return;
         }
         this.addNewline();
-        bodyLines.forEach((bodyLine) => this.writeToStdOut(`   ${bodyLine}${os_1.EOL}`));
+        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
     }
     applyNxPrefix(color = 'cyan', text) {
         let nxPrefix = '';
         if (chalk[color]) {
-            nxPrefix = `${chalk[color]('>')} ${chalk.reset.inverse.bold[color](` ${this.cliName} `)}`;
+            nxPrefix = chalk.reset.inverse.bold[color](` ${this.cliName} `);
         }
         else {
-            nxPrefix = `${chalk.keyword(color)('>')} ${chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `)}`;
+            nxPrefix = chalk.reset.inverse.bold.keyword(color)(` ${this.cliName} `);
         }
         return `${nxPrefix}  ${text}`;
     }
@@ -90,7 +91,7 @@ class CLIOutput {
         return ['', this.getVerticalSeparator(color), ''];
     }
     getVerticalSeparator(color) {
-        return `${this.X_PADDING}${chalk.dim[color](this.VERTICAL_SEPARATOR)}`;
+        return chalk.dim[color](this.VERTICAL_SEPARATOR);
     }
     error({ title, slug, bodyLines }) {
         this.addNewline();
@@ -152,10 +153,44 @@ class CLIOutput {
     }
     logCommand(message, taskStatus) {
         this.addNewline();
-        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
-        const commandOutputWithStatus = this.addTaskStatus(taskStatus, commandOutput);
+        this.writeToStdOut(this.getCommandWithStatus(message, taskStatus));
+        this.addNewline();
+        this.addNewline();
+    }
+    logCommandOutput(message, taskStatus, output) {
+        let commandOutputWithStatus = this.getCommandWithStatus(message, taskStatus);
+        if (process.env.NX_SKIP_LOG_GROUPING !== 'true' &&
+            process.env.GITHUB_ACTIONS) {
+            const icon = this.getStatusIcon(taskStatus);
+            commandOutputWithStatus = `${GH_GROUP_PREFIX}${icon} ${commandOutputWithStatus}`;
+        }
+        this.addNewline();
         this.writeToStdOut(commandOutputWithStatus);
         this.addNewline();
+        this.addNewline();
+        this.writeToStdOut(output);
+        if (process.env.NX_SKIP_LOG_GROUPING !== 'true' &&
+            process.env.GITHUB_ACTIONS) {
+            this.writeToStdOut(GH_GROUP_SUFFIX);
+        }
+    }
+    getCommandWithStatus(message, taskStatus) {
+        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
+        return this.addTaskStatus(taskStatus, commandOutput);
+    }
+    getStatusIcon(taskStatus) {
+        switch (taskStatus) {
+            case 'success':
+                return '✅';
+            case 'failure':
+                return '❌';
+            case 'skipped':
+            case 'local-cache-kept-existing':
+                return '⏩';
+            case 'local-cache':
+            case 'remote-cache':
+                return '🔁';
+        }
     }
     normalizeMessage(message) {
         if (message.startsWith('nx run ')) {

package/src/utils/package-json.d.ts

@@ -1,12 +1,11 @@
 import { InputDefinition, TargetConfiguration } from '../config/workspace-json-project-json';
-export type PackageJsonTargetConfiguration = Omit<TargetConfiguration, 'executor'>;
 export interface NxProjectPackageJsonConfiguration {
     implicitDependencies?: string[];
     tags?: string[];
     namedInputs?: {
         [inputName: string]: (string | InputDefinition)[];
     };
-    targets?: Record<string, PackageJsonTargetConfiguration>;
+    targets?: Record<string, TargetConfiguration>;
     includedScripts?: string[];
 }
 export type ArrayPackageGroup = {
@@ -53,6 +52,7 @@ export interface PackageJson {
     workspaces?: string[] | {
         packages: string[];
     };
+    publishConfig?: Record<string, string>;
     nx?: NxProjectPackageJsonConfiguration;
     generators?: string;
     schematics?: string;
@@ -65,8 +65,8 @@ export declare function normalizePackageGroup(packageGroup: PackageGroup): Array
 export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigrationsConfiguration & {
     packageGroup?: ArrayPackageGroup;
 };
-export declare function buildTargetFromScript(script: string, nx: NxProjectPackageJsonConfiguration): TargetConfiguration;
-export declare function readTargetsFromPackageJson({ scripts, nx }: PackageJson): Record<string, TargetConfiguration<any>>;
+export declare function buildTargetFromScript(script: string): TargetConfiguration;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-json.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readModulePackageJson = exports.readModulePackageJsonWithoutFallbacks = exports.readTargetsFromPackageJson = exports.buildTargetFromScript = exports.readNxMigrateConfig = exports.normalizePackageGroup = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const project_configuration_utils_1 = require("../project-graph/utils/project-configuration-utils");
 const fileutils_1 = require("./fileutils");
 const installation_directory_1 = require("./installation-directory");
 function normalizePackageGroup(packageGroup) {
@@ -37,27 +38,32 @@ function readNxMigrateConfig(json) {
     };
 }
 exports.readNxMigrateConfig = readNxMigrateConfig;
-function buildTargetFromScript(script, nx) {
-    const nxTargetConfiguration = nx?.targets?.[script] || {};
+function buildTargetFromScript(script) {
     return {
-        ...nxTargetConfiguration,
         executor: 'nx:run-script',
         options: {
-            ...(nxTargetConfiguration.options || {}),
             script,
         },
     };
 }
 exports.buildTargetFromScript = buildTargetFromScript;
-function readTargetsFromPackageJson({ scripts, nx }) {
+function readTargetsFromPackageJson(packageJson) {
+    const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
-    Object.keys(scripts || {}).forEach((script) => {
-        if (!nx?.includedScripts || nx?.includedScripts.includes(script)) {
-            res[script] = buildTargetFromScript(script, nx);
-        }
-    });
-    // Add implicit nx-release-publish target for all package.json files to allow for lightweight configuration for package based repos
-    if (!res['nx-release-publish']) {
+    const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
+    //
+    for (const script of includedScripts) {
+        res[script] = buildTargetFromScript(script);
+    }
+    for (const targetName in nx?.targets) {
+        res[targetName] = (0, project_configuration_utils_1.mergeTargetConfigurations)(nx?.targets[targetName], res[targetName]);
+    }
+    /**
+     * Add implicit nx-release-publish target for all package.json files that are
+     * not marked as `"private": true` to allow for lightweight configuration for
+     * package based repos.
+     */
+    if (!isPrivate && !res['nx-release-publish']) {
         res['nx-release-publish'] = {
             dependsOn: ['^nx-release-publish'],
             executor: '@nx/js:release-publish',

package/src/utils/package-manager.d.ts

@@ -3,6 +3,7 @@ export interface PackageManagerCommands {
     preInstall?: string;
     install: string;
     ciInstall: string;
+    updateLockFile: string;
     add: string;
     addDev: string;
     rm: string;
@@ -15,6 +16,12 @@ export interface PackageManagerCommands {
  * Detects which package manager is used in the workspace based on the lock file.
  */
 export declare function detectPackageManager(dir?: string): PackageManager;
+/**
+ * Returns true if the workspace is using npm workspaces, yarn workspaces, or pnpm workspaces.
+ * @param packageManager The package manager to use. If not provided, it will be detected based on the lock file.
+ * @param root The directory the commands will be ran inside of. Defaults to the current workspace's root.
+ */
+export declare function isWorkspacesEnabled(packageManager?: PackageManager, root?: string): boolean;
 /**
  * Returns commands for the package manager used in the workspace.
  * By default, the package manager is derived based on the lock file,

package/src/utils/package-manager.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageRegistryPack = exports.packageRegistryView = exports.resolvePackageVersionUsingInstallation = exports.resolvePackageVersionUsingRegistry = exports.createTempNpmDirectory = exports.copyPackageManagerConfigurationFiles = exports.modifyYarnRcToFitNewDirectory = exports.modifyYarnRcYmlToFitNewDirectory = exports.findFileInPackageJsonDirectory = exports.getPackageManagerVersion = exports.getPackageManagerCommand = exports.detectPackageManager = void 0;
+exports.packageRegistryPack = exports.packageRegistryView = exports.resolvePackageVersionUsingInstallation = exports.resolvePackageVersionUsingRegistry = exports.createTempNpmDirectory = exports.copyPackageManagerConfigurationFiles = exports.modifyYarnRcToFitNewDirectory = exports.modifyYarnRcYmlToFitNewDirectory = exports.findFileInPackageJsonDirectory = exports.getPackageManagerVersion = exports.getPackageManagerCommand = exports.isWorkspacesEnabled = exports.detectPackageManager = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
+const semver_1 = require("semver");
 const tmp_1 = require("tmp");
 const util_1 = require("util");
+const configuration_1 = require("../config/configuration");
+const file_utils_1 = require("../project-graph/file-utils");
 const fileutils_1 = require("./fileutils");
 const package_json_1 = require("./package-json");
-const semver_1 = require("semver");
 const workspace_root_1 = require("./workspace-root");
-const configuration_1 = require("../config/configuration");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * Detects which package manager is used in the workspace based on the lock file.
@@ -26,6 +27,20 @@ function detectPackageManager(dir = '') {
                 : 'npm'));
 }
 exports.detectPackageManager = detectPackageManager;
+/**
+ * Returns true if the workspace is using npm workspaces, yarn workspaces, or pnpm workspaces.
+ * @param packageManager The package manager to use. If not provided, it will be detected based on the lock file.
+ * @param root The directory the commands will be ran inside of. Defaults to the current workspace's root.
+ */
+function isWorkspacesEnabled(packageManager = detectPackageManager(), root = workspace_root_1.workspaceRoot) {
+    if (packageManager === 'pnpm') {
+        return (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
+    }
+    // yarn and pnpm both use the same 'workspaces' property in package.json
+    const packageJson = (0, file_utils_1.readPackageJson)();
+    return !!packageJson?.workspaces;
+}
+exports.isWorkspacesEnabled = isWorkspacesEnabled;
 /**
  * Returns commands for the package manager used in the workspace.
  * By default, the package manager is derived based on the lock file,
@@ -51,6 +66,9 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
                 ciInstall: useBerry
                     ? 'yarn install --immutable'
                     : 'yarn install --frozen-lockfile',
+                updateLockFile: useBerry
+                    ? 'yarn install --mode update-lockfile'
+                    : 'yarn install',
                 add: useBerry ? 'yarn add' : 'yarn add -W',
                 addDev: useBerry ? 'yarn add -D' : 'yarn add -D -W',
                 rm: 'yarn remove',
@@ -66,8 +84,9 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
             const includeDoubleDashBeforeArgs = (0, semver_1.lt)(pnpmVersion, '7.0.0');
             const isPnpmWorkspace = (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
             return {
-                install: 'pnpm install --no-frozen-lockfile',
+                install: 'pnpm install --no-frozen-lockfile', // explicitly disable in case of CI
                 ciInstall: 'pnpm install --frozen-lockfile',
+                updateLockFile: 'pnpm install --lockfile-only',
                 add: isPnpmWorkspace ? 'pnpm add -w' : 'pnpm add',
                 addDev: isPnpmWorkspace ? 'pnpm add -Dw' : 'pnpm add -D',
                 rm: 'pnpm rm',
@@ -85,6 +104,7 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
             return {
                 install: 'npm install',
                 ciInstall: 'npm ci',
+                updateLockFile: 'npm install --package-lock-only',
                 add: 'npm install',
                 addDev: 'npm install -D',
                 rm: 'npm rm',

package/src/utils/params.d.ts

@@ -1,5 +1,5 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { TargetConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { NxJsonConfiguration } from '../config/nx-json';
+import type { TargetConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 type PropertyDescription = {
     type?: string | string[];
     required?: string[];
@@ -26,8 +26,10 @@ type PropertyDescription = {
         $source: 'projectName';
     } | {
         $source: 'unparsed';
+    } | {
+        $source: 'workingDirectory';
     };
-    additionalProperties?: boolean;
+    additionalProperties?: boolean | PropertyDescription;
     const?: any;
     'x-prompt'?: string | {
         message: string;
@@ -46,6 +48,9 @@ type PropertyDescription = {
     pattern?: string;
     minLength?: number;
     maxLength?: number;
+    patternProperties?: {
+        [pattern: string]: PropertyDescription;
+    };
 };
 type Properties = {
     [p: string]: PropertyDescription;
@@ -57,11 +62,14 @@ export type Schema = {
     oneOf?: Partial<Schema>[];
     description?: string;
     definitions?: Properties;
-    additionalProperties?: boolean;
+    additionalProperties?: boolean | PropertyDescription;
     examples?: {
         command: string;
         description?: string;
     }[];
+    patternProperties?: {
+        [pattern: string]: PropertyDescription;
+    };
 };
 export type Unmatched = {
     name: string;