nx 23.2.0-beta.5 → 23.2.0-beta.7

package/dist/src/command-line/init/init-v2.js

@@ -401,6 +401,7 @@ async function runInit(options, baseMeta) {
 function getPluginReason(plugin) {
     const reasonMap = {
         '@nx/eslint': 'eslint detected in dependencies',
+        '@nx/oxlint': 'oxlint detected in dependencies',
         '@nx/storybook': 'storybook detected in dependencies',
         '@nx/vite': 'vite detected in dependencies',
         '@nx/vitest': 'vitest detected in dependencies',
@@ -448,6 +449,7 @@ function parsePluginsFlag(value) {
 const npmPackageToPluginMap = {
     // Generic JS tools
     eslint: '@nx/eslint',
+    oxlint: '@nx/oxlint',
     storybook: '@nx/storybook',
     // Bundlers
     vite: '@nx/vite',

package/dist/src/command-line/migrate/migrate.js

@@ -28,6 +28,7 @@ const util_1 = require("util");
 const fileutils_1 = require("../../utils/fileutils");
 const tar_1 = require("../../utils/tar");
 const write_formatted_json_file_1 = require("../../utils/write-formatted-json-file");
+const shell_quoting_1 = require("../../utils/shell-quoting");
 const logger_1 = require("../../utils/logger");
 const git_utils_1 = require("../../utils/git-utils");
 const command_line_utils_1 = require("../../utils/command-line-utils");
@@ -1989,13 +1990,10 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
         retainedAtSuccess: (0, migrate_output_1.retainedMigrations)(outcomes).map((p) => `${p.package}: ${p.name}`),
     };
 }
-// Forwards this invocation's raw argv to the workspace-local nx, used from
-// each run path's temp-installation check (`!__dirname.startsWith(workspaceRoot)`)
-// right after its gated `runInstall` pre-install. `runNxSync` resolves nx
-// through the workspace's package manager at spawn time, so the child runs
-// the bytes that pre-install put in place.
+// nx is located at spawn time, after the gated pre-install, so the child runs
+// the bytes that install put in place.
 function handOffToLocalNx(args) {
-    const exitCode = runOrReturnExitCode(() => (0, child_process_2.runNxSync)(`migrate ${args.join(' ')}`, {
+    const exitCode = runOrReturnExitCode(() => (0, child_process_2.runNxArgvSync)(['migrate', ...args], {
         stdio: ['inherit', 'inherit', 'inherit'],
         env: {
             ...process.env,
@@ -2283,10 +2281,14 @@ function stringifyCaught(e) {
 // A resolver-based lookup (including `resolvePackageJsonWithoutCachePollution`,
 // which does defeat Node's package self-reference) is the wrong tool here:
 // resolvers fall back to NODE_PATH after the explicit paths, and NODE_PATH
-// names the temp installation when this runs there, while the hand-off spawn
-// locates nx through the package manager's bin lookup, which ignores
-// NODE_PATH. The PnP branch below stays bespoke either way: a resolver cannot
-// see into the zip cache without the PnP runtime.
+// names the temp installation when this runs there. The scan below reads its
+// candidate directories itself, so neither NODE_PATH nor self-reference can
+// reach it; `getNxBin` (utils/child-process.ts), which locates the nx the
+// hand-off spawns, avoids resolvers for the same reason, over a narrower set
+// of directories: it skips `.nx/installation`, declines a root without a
+// package.json, and stops at the nearest install rather than reading past an
+// unusable one. The PnP branch below stays bespoke either way: a resolver
+// cannot see into the zip cache without the PnP runtime.
 function readLocalNxVersion(root) {
     // A PnP manifest is consulted only when yarn drives the hand-off:
     // `getRunNxBaseCommand` builds the hand-off command through this same
@@ -2387,12 +2389,13 @@ function readLocalNxVersion(root) {
 // The workspace's own install locations first (.nx/installation, root), then
 // ancestor directories: package-manager executable lookup ascends (npx and
 // bun always, pnpm and yarn inside an outer workspace) and hoisted layouts
-// install nx above the workspace root. An unrelated ancestor install the
-// hand-off's spawn would not run can be read here; the guards then judge that
-// version rather than failing open. A hand-off issued anyway may not fail
-// visibly: yarn reports "command not found", but pnpm exec falls back to an
-// nx on PATH, so the version read here is the readable answer, not
-// necessarily the executed one.
+// install nx above the workspace root. `getNxBin` ascends too, so an ancestor
+// read here is usually the one the hand-off spawns. They diverge for a
+// `.nx/installation` workspace, which `getNxBin` declines, and where the only
+// nx found sits past the package manager's own lookup boundary and the spawn
+// has fallen back to that manager: yarn then reports "command not found"
+// while pnpm exec lands on an nx on PATH. The version read here is therefore
+// the readable answer, not necessarily the executed one.
 function scanNodeModulesForNxVersion(root) {
     const searchPaths = [...(0, installation_directory_1.getNxRequirePaths)(root)];
     for (let dir = (0, path_1.dirname)(root);; dir = (0, path_1.dirname)(dir)) {
@@ -2469,9 +2472,11 @@ async function runMigration() {
         // that parsed the flags, so it needs no capability check. Two lookups
         // can still diverge from the running install, both properties of the
         // spawn machinery rather than of this fallback: a `.nx/installation`
-        // beside a root package.json, and a spawn that misses the workspace
-        // install and falls back to an nx on PATH (pnpm exec).
-        const runLocalMigrate = () => runOrReturnExitCode(() => (0, child_process_2.runNxSync)(`_migrate ${process.argv.slice(3).join(' ')}`, {
+        // beside a root package.json, and, once the spawn falls back to the
+        // package manager, a lookup that misses the workspace install and lands
+        // on an nx on PATH (pnpm exec).
+        const forwardedArgv = process.argv.slice(3);
+        const runLocalMigrate = () => runOrReturnExitCode(() => (0, child_process_2.runNxArgvSync)(['_migrate', ...forwardedArgv], {
             stdio: ['inherit', 'inherit', 'inherit'],
         }));
         if (process.env.NX_USE_LOCAL !== 'true' &&
@@ -2505,14 +2510,26 @@ async function runMigration() {
                 process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
                 delete process.env.npm_config_registry;
             }
-            // Intentionally not runNxSync: `p` is an nx CLI freshly installed into a
-            // temp dir by nxCliPath() (latest, or NX_MIGRATE_CLI_VERSION), so
-            // migrations run with an up-to-date migrate implementation instead of
-            // the workspace's current nx.
-            return runOrReturnExitCode(() => (0, child_process_1.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
-                stdio: ['inherit', 'inherit', 'inherit'],
-                windowsHide: true,
-            }));
+            // Intentionally not the workspace's nx: `p` is an nx CLI freshly
+            // installed into a temp dir by nxCliPath() (latest, or
+            // NX_MIGRATE_CLI_VERSION), so migrations run with an up-to-date migrate
+            // implementation. `p` is <tmpDir>/node_modules/.bin/nx, a shell shim;
+            // spawning the entry point that install's own manifest names instead
+            // keeps the forwarded argv out of a shell. That install declares nx
+            // itself, so it is read without ascending: an nx above the temp dir is
+            // one nothing asked for, and the shim below is the answer instead.
+            const tempNxEntry = (0, child_process_2.readInstalledNxBin)((0, path_1.dirname)((0, path_1.dirname)((0, path_1.dirname)(p))));
+            return runOrReturnExitCode(() => tempNxEntry
+                ? (0, child_process_2.runNxArgvSync)(['_migrate', ...forwardedArgv], {
+                    stdio: ['inherit', 'inherit', 'inherit'],
+                    nxBin: tempNxEntry,
+                })
+                : (0, child_process_1.execSync)(`${(0, shell_quoting_1.quoteShellArg)(p)} _migrate ${forwardedArgv
+                    .map(shell_quoting_1.quoteShellArg)
+                    .join(' ')}`, {
+                    stdio: ['inherit', 'inherit', 'inherit'],
+                    windowsHide: true,
+                }));
         }
         return runLocalMigrate();
     });

package/dist/src/command-line/migrate/version-skew-guard.d.ts

@@ -48,10 +48,9 @@ export declare function resolveNewMigrateFlagsRunTarget(options: {
  * because the invoking nx's version is not forwarded across hop A; the
  * refusal names the workspace update that resolves it.
  *
- * `readLocalNxVersion` returns undefined when no readable nx install exists
- * at or above the workspace root; that case does not block. The hand-off
- * spawns the `nx migrate` wrapper, and without an nx installation to
- * delegate to it exits visibly rather than running anything.
+ * `readLocalNxVersion` returning undefined does not block: the hand-off then
+ * resolves nx as it always does, which may fail visibly or land on another nx
+ * the package manager locates.
  */
 export declare function assertWorkspaceNxSupportsNewMigrateFlags(options: {
     argv: string[];

package/dist/src/command-line/migrate/version-skew-guard.js

@@ -18,8 +18,8 @@ const version_utils_1 = require("./version-utils");
 // this floor and route to a temp CLI that drops the new flags and runs the
 // plan phase instead.
 exports.NEW_MIGRATE_FLAGS_FLOOR = '23.2.0';
-// yargs accepts both spellings and the raw argv is forwarded verbatim across
-// both migrate hops, so detection must catch each one.
+// yargs accepts both spellings and the raw argv is forwarded across both
+// migrate hops, so detection must catch each one.
 exports.NEW_MIGRATE_FLAGS = ['--run-migration', '--runMigration'];
 /**
  * Matches an exact token or `<flag>=<value>`. The `=` matters: a bare
@@ -132,10 +132,9 @@ async function resolveNewMigrateFlagsRunTarget(options) {
  * because the invoking nx's version is not forwarded across hop A; the
  * refusal names the workspace update that resolves it.
  *
- * `readLocalNxVersion` returns undefined when no readable nx install exists
- * at or above the workspace root; that case does not block. The hand-off
- * spawns the `nx migrate` wrapper, and without an nx installation to
- * delegate to it exits visibly rather than running anything.
+ * `readLocalNxVersion` returning undefined does not block: the hand-off then
+ * resolves nx as it always does, which may fail visibly or land on another nx
+ * the package manager locates.
  */
 function assertWorkspaceNxSupportsNewMigrateFlags(options) {
     const flag = findNewMigrateFlag(options.argv);

package/dist/src/command-line/reset/reset.js

@@ -137,7 +137,12 @@ function cleanupCacheEntries() {
 }
 function cleanupNativeFileCache() {
     return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
-        (0, node_fs_1.rmSync)((0, native_file_cache_location_1.getNativeFileCacheLocation)(), { recursive: true, force: true });
+        // Null when the native cache root is not a real directory we own, which
+        // would mean deleting through a path another user planted.
+        const cacheDir = (0, native_file_cache_location_1.getNativeFileCacheLocationToDelete)();
+        if (cacheDir) {
+            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        }
     });
 }
 function cleanupWorkspaceData() {

package/dist/src/command-line/run/run-one.js

@@ -51,6 +51,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
         process.exit(status);
     }
 }

package/dist/src/command-line/run-many/run-many.js

@@ -41,6 +41,7 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
         process.exit(status);
     }
 }