nx 23.2.0-beta.1 → 23.2.0-beta.11

package/dist/src/utils/child-process.d.ts

@@ -1,7 +1,37 @@
-import { type ExecOptions, type ExecSyncOptions } from 'child_process';
+import { type ExecOptions, type ExecSyncOptions, type SpawnSyncOptions } from 'child_process';
 import { PackageManagerCommands } from './package-manager';
 import { ChildProcess } from '../native';
 export declare function getRunNxBaseCommand(packageManagerCommand?: PackageManagerCommands, cwd?: string): string;
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+export declare function getNxBin(root?: string): string | null;
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+export declare function readInstalledNxBin(dir: string): string | null;
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+export declare function runNxArgvSync(argv: string[], options?: SpawnSyncOptions & {
+    cwd?: string;
+    nxBin?: string;
+}): void;
 export declare function runNxSync(cmd: string, options?: ExecSyncOptions & {
     cwd?: string;
     packageManagerCommand?: PackageManagerCommands;

package/dist/src/utils/child-process.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PseudoTtyProcess = void 0;
 exports.getRunNxBaseCommand = getRunNxBaseCommand;
+exports.getNxBin = getNxBin;
+exports.readInstalledNxBin = readInstalledNxBin;
+exports.runNxArgvSync = runNxArgvSync;
 exports.runNxSync = runNxSync;
 exports.runNxAsync = runNxAsync;
 const child_process_1 = require("child_process");
@@ -10,9 +13,14 @@ const path_1 = require("path");
 const package_manager_1 = require("./package-manager");
 const workspace_root_1 = require("./workspace-root");
 const exit_codes_1 = require("./exit-codes");
+const fileutils_1 = require("./fileutils");
+const shell_quoting_1 = require("./shell-quoting");
 function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
         if (!packageManagerCommand) {
+            // `readLocalNxVersion` (command-line/migrate/migrate.ts) mirrors this
+            // selector to predict which nx a spawn will run, for the workspaces
+            // `getNxBin` declines to resolve; keep the two in sync.
             const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
             packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
         }
@@ -28,6 +36,101 @@ function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
         }
     }
 }
+/**
+ * Locate an nx entry point to spawn for the workspace at `root`, so a caller
+ * can run it directly instead of going through a shell. `findInstalledNxBin`
+ * decides which one.
+ *
+ * Null means nothing may be spawned directly, leaving the caller to fall back
+ * to `getRunNxBaseCommand`. Null is therefore always safe: it costs the
+ * argument fidelity a direct spawn buys, never the ability to run.
+ */
+function getNxBin(root = workspace_root_1.workspaceRoot) {
+    // A workspace with no root package.json runs nx through the `./nx` wrapper,
+    // which reinstalls `.nx/installation` whenever it drifts from nx.json's
+    // `installation.version`. Spawning the resolved entry point would skip that
+    // sync, and a migration is precisely when the version changes.
+    if (!(0, fs_1.existsSync)((0, path_1.join)(root, 'package.json'))) {
+        return null;
+    }
+    return findInstalledNxBin(root);
+}
+/**
+ * The entry point the nx installed directly under `dir` names, with no ascent
+ * to `dir`'s ancestors. For an installation that declares nx itself, such as
+ * the temp CLI `nx migrate` builds, an ancestor's nx is never the right answer.
+ */
+function readInstalledNxBin(dir) {
+    const packageDir = (0, path_1.join)(dir, 'node_modules', 'nx');
+    const manifest = (0, path_1.join)(packageDir, 'package.json');
+    if (!(0, fs_1.existsSync)(manifest)) {
+        return null;
+    }
+    let bin;
+    try {
+        ({ bin } = (0, fileutils_1.readJsonFile)(manifest));
+    }
+    catch {
+        return null;
+    }
+    // npm accepts both the single-entry shorthand and the map form.
+    const entry = typeof bin === 'string' ? bin : bin?.nx;
+    return typeof entry === 'string' ? (0, path_1.join)(packageDir, entry) : null;
+}
+// Ascend to the nearest installed nx and take the entry point its `bin` field
+// names, which is the file a package manager links into `node_modules/.bin`.
+// Deliberately npx-shaped: npx and bun ascend unconditionally while pnpm and
+// yarn stop at an outer workspace, so this can name an nx those two would
+// decline to run.
+//
+// Deliberately not a resolver. Resolvers answer from NODE_PATH once their
+// explicit paths miss, and `nxCliPath` (command-line/migrate/migrate.ts) points
+// NODE_PATH at the temp installation before spawning it; they also answer
+// through package self-reference, which hands back the running nx whatever
+// `paths` they are given. Either one lets the temp installation hand off to
+// itself, which for `--run-migrations` re-enters the same hand-off and respawns
+// without end.
+function findInstalledNxBin(root) {
+    for (let dir = root;; dir = (0, path_1.dirname)(dir)) {
+        // The nearest install wins, so an unusable manifest there ends the search
+        // rather than deferring to an ancestor.
+        if ((0, fs_1.existsSync)((0, path_1.join)(dir, 'node_modules', 'nx', 'package.json'))) {
+            return readInstalledNxBin(dir);
+        }
+        if (dir === (0, path_1.dirname)(dir)) {
+            return null;
+        }
+    }
+}
+/**
+ * Run a nx command, passing the arguments through as an argv array.
+ *
+ * When `getNxBin` names an entry point, the child is spawned directly with no
+ * shell in between, so every argument reaches the child exactly as provided:
+ * shell metacharacters (`(`, `%`, `^`, spaces, quotes) are data, not syntax.
+ * Otherwise falls back to the package-manager + shell path, where every
+ * argument goes through `quoteShellArg` and the Windows limits it documents
+ * apply.
+ */
+function runNxArgvSync(argv, options) {
+    let { nxBin, ...spawnOptions } = options ?? {};
+    spawnOptions.cwd ??= process.cwd();
+    spawnOptions.windowsHide ??= true;
+    nxBin ??= getNxBin((0, workspace_root_1.workspaceRootInner)(spawnOptions.cwd, null) ?? workspace_root_1.workspaceRoot);
+    if (!nxBin) {
+        runNxSync(argv.map(shell_quoting_1.quoteShellArg).join(' '), spawnOptions);
+        return;
+    }
+    const result = (0, child_process_1.spawnSync)(process.execPath, [nxBin, ...argv], spawnOptions);
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        const error = new Error(`Command failed: nx ${argv.join(' ')} (exit code ${result.status})`);
+        error.status = result.status ?? 1;
+        throw error;
+    }
+}
 function runNxSync(cmd, options) {
     let { packageManagerCommand, ...execSyncOptions } = options ?? {};
     execSyncOptions.cwd ??= process.cwd();

package/dist/src/utils/chunkify.d.ts

@@ -1,4 +1,10 @@
-export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
+export declare function chunkify(target: string[], maxChunkLength?: number, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure?: (item: string) => number): string[][];
 /**
  * Get the maximum length of a command-line argument string based on current platform
  *

package/dist/src/utils/chunkify.js

@@ -3,22 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkify = chunkify;
 exports.getMaxArgLength = getMaxArgLength;
 const TERMINAL_SIZE = getMaxArgLength();
-function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500, 
+/**
+ * How long each entry will be once it reaches the command line. Callers that
+ * quote or escape afterwards pass that transformation's length here, so the
+ * chunk is sized against what is actually spawned rather than the raw string.
+ */
+measure = (item) => item.length) {
     const chunks = [];
     let currentChunk = [];
     let currentChunkLength = 0;
     for (const file of target) {
+        const length = measure(file);
         if (
         // Prevent empty chunk if first file path is longer than maxChunkLength
         currentChunk.length &&
             // +1 accounts for the space between file names
-            currentChunkLength + file.length + 1 >= maxChunkLength) {
+            currentChunkLength + length + 1 >= maxChunkLength) {
             chunks.push(currentChunk);
             currentChunk = [];
             currentChunkLength = 0;
         }
         currentChunk.push(file);
-        currentChunkLength += file.length + 1;
+        currentChunkLength += length + 1;
     }
     chunks.push(currentChunk);
     return chunks;

package/dist/src/utils/exit-codes.d.ts

@@ -13,3 +13,12 @@ export declare const EXPECTED_TERMINATION_SIGNALS: Set<number>;
  * Handles both Linux exact-match and macOS strsignal formats (e.g. "Terminated by Hangup: 1").
  */
 export declare function messageToCode(message: string): number;
+/**
+ * Ends the process the way an interrupted process ends: by SIGINT, not by
+ * exiting with its conventional code.
+ *
+ * A shell reports 130 either way, but a parent using waitpid sees
+ * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
+ * check to tell "the user pressed Ctrl+C" from "the command failed".
+ */
+export declare function exitAsInterrupted(): never;

package/dist/src/utils/exit-codes.js

@@ -4,6 +4,7 @@ exports.EXPECTED_TERMINATION_SIGNALS = void 0;
 exports.signalToCode = signalToCode;
 exports.codeToSignal = codeToSignal;
 exports.messageToCode = messageToCode;
+exports.exitAsInterrupted = exitAsInterrupted;
 /**
  * Translates NodeJS signals to numeric exit code
  * @param signal
@@ -73,3 +74,21 @@ function messageToCode(message) {
         return 1;
     }
 }
+/**
+ * Ends the process the way an interrupted process ends: by SIGINT, not by
+ * exiting with its conventional code.
+ *
+ * A shell reports 130 either way, but a parent using waitpid sees
+ * `signal: 'SIGINT'` rather than `code: 130`, which is what tools wrapping nx
+ * check to tell "the user pressed Ctrl+C" from "the command failed".
+ */
+function exitAsInterrupted() {
+    // Windows has no signal disposition to inherit - `process.kill` there
+    // terminates with an arbitrary code - so keep the 128+SIGINT convention.
+    if (process.platform !== 'win32') {
+        // Any listener would swallow this; the default action is what terminates.
+        process.removeAllListeners('SIGINT');
+        process.kill(process.pid, 'SIGINT');
+    }
+    process.exit(130);
+}

package/dist/src/utils/fileutils.d.ts

@@ -27,6 +27,11 @@ interface YamlReadOptions {
      * Compatibility with JSON.parse behaviour. If true, then duplicate keys in a mapping will override values rather than throwing an error.
      */
     json?: boolean;
+    /**
+     * Resolves only the tags every YAML parser must support, so every scalar stays
+     * a string instead of `true` or `12`.
+     */
+    failsafe?: boolean;
 }
 /**
  * Reads a YAML file and returns the object the YAML content represents.

package/dist/src/utils/fileutils.js

@@ -41,8 +41,13 @@ function readJsonFile(path, options) {
  */
 function readYamlFile(path, options) {
     const content = (0, node_fs_1.readFileSync)(path, 'utf-8');
-    const { load } = require('@zkochan/js-yaml');
-    return load(content, { ...options, filename: path });
+    const { load, FAILSAFE_SCHEMA } = require('@zkochan/js-yaml');
+    const { failsafe, ...loadOptions } = options ?? {};
+    return load(content, {
+        ...loadOptions,
+        ...(failsafe ? { schema: FAILSAFE_SCHEMA } : {}),
+        filename: path,
+    });
 }
 /**
  * Serializes the given data to JSON and writes it to a file.

package/dist/src/utils/formatters/index.d.ts

@@ -0,0 +1,13 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Adding a member here does NOT reliably break compilation: the repo builds
+ * with `strict: false`, so a `switch` that omits one is not an error. The
+ * `never` assertions and type-keyed tables that do catch it fail immediately
+ * inside `packages/nx`, but the ones in devkit and `@nx/js` read the type from
+ * its emitted declarations, so those only fail once it has been rebuilt.
+ */
+export type FormatterType = 'prettier' | 'oxfmt';
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+export declare function resetFormatterWarningsForTesting(): void;
+export declare function detectFormatter(root: string): FormatterType | null;
+export declare function detectFormatterInTree(tree: Tree): FormatterType | null;

package/dist/src/utils/formatters/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetFormatterWarningsForTesting = resetFormatterWarningsForTesting;
+exports.detectFormatter = detectFormatter;
+exports.detectFormatterInTree = detectFormatterInTree;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const json_1 = require("../../generators/utils/json");
+const fileutils_1 = require("../fileutils");
+const oxfmt_1 = require("./oxfmt");
+const prettier_1 = require("./prettier");
+const logger_1 = require("../logger");
+// Once per process: detection runs on every one of 200+ `formatFiles` call sites.
+let warnedBothConfigured = false;
+function warnBothConfigured() {
+    warnedBothConfigured = true;
+    logger_1.logger.warn('Both an oxfmt and a prettier config were found. Nx is formatting with ' +
+        'oxfmt. Delete the config you are not using to make the choice ' +
+        'explicit: https://nx.dev/docs/reference/code-formatting');
+}
+/** Test-only: the warn-once flag is module state and would leak between cases. */
+function resetFormatterWarningsForTesting() {
+    warnedBothConfigured = false;
+}
+function detectFormatter(root) {
+    if ((0, oxfmt_1.isUsingOxfmt)(root)) {
+        // Flag first, so the lookup stops repeating once we have warned.
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettier)(root)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettier)(root)) {
+        return 'prettier';
+    }
+    // Neither is configured. Both formatters run on their defaults, so a
+    // dependency declared in the root package.json is the only statement of
+    // intent an unconfigured workspace gives. #30426 ruled out treating prettier
+    // as *resolvable in node_modules*, which a declared dependency is not.
+    const packageJsonPath = (0, node_path_1.join)(root, 'package.json');
+    if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+        return detectFormatterFromDependencies((0, fileutils_1.readJsonFile)(packageJsonPath));
+    }
+    return null;
+}
+function detectFormatterInTree(tree) {
+    if ((0, oxfmt_1.isUsingOxfmtInTree)(tree)) {
+        if (!warnedBothConfigured && (0, prettier_1.isUsingPrettierInTree)(tree)) {
+            warnBothConfigured();
+        }
+        return 'oxfmt';
+    }
+    if ((0, prettier_1.isUsingPrettierInTree)(tree)) {
+        return 'prettier';
+    }
+    // See detectFormatter: a declared dependency is the fallback for both.
+    if (tree.exists('package.json')) {
+        return detectFormatterFromDependencies((0, json_1.readJson)(tree, 'package.json'));
+    }
+    return null;
+}
+/** oxfmt first, matching the precedence the config files already have. */
+function detectFormatterFromDependencies(packageJson) {
+    if (hasDependency(packageJson, 'oxfmt')) {
+        return 'oxfmt';
+    }
+    if (hasDependency(packageJson, 'prettier')) {
+        return 'prettier';
+    }
+    return null;
+}
+function hasDependency(packageJson, name) {
+    return Boolean(packageJson.dependencies?.[name] ?? packageJson.devDependencies?.[name]);
+}

package/dist/src/utils/formatters/oxfmt.d.ts

@@ -0,0 +1,32 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * Config filenames oxfmt *discovers* - narrower than the set `-c` accepts.
+ * Measured against 0.60.0: `oxfmt.config.{js,cjs,mjs,cts}` load when named
+ * but are never searched for, so treating one as config would format on
+ * options oxfmt ignores. No precedence order - oxfmt fails with
+ * "Both '<a>' and '<b>' found in <dir>" when a directory holds two.
+ */
+export declare const oxfmtConfigFiles: string[];
+export declare function isUsingOxfmt(root: string): boolean;
+export declare function isUsingOxfmtInTree(tree: Tree): boolean;
+export declare function getOxfmtBinPath(): string;
+export declare function writeWithOxfmt(patterns: string[], cwd?: string): void;
+export declare function checkWithOxfmt(patterns: string[]): Promise<string[]>;
+/**
+ * Nothing is written to disk: staging files inside the workspace would race the
+ * daemon's watcher and the project graph mid-generator.
+ *
+ * A path is absent from the result when oxfmt has no parser for it, an ignore
+ * file covers it, or it is already formatted. One unparseable file fails only
+ * itself; the rest of the batch still applies.
+ */
+export declare function formatFilesWithOxfmt(files: {
+    path: string;
+    content: string;
+}[], workspaceRoot: string, seedConfig?: {
+    name: string;
+    content: string;
+}, rootConfigNames?: readonly string[], read?: (relativePath: string) => string | null | undefined): Promise<{
+    formatted: Map<string, string>;
+    errors?: string[];
+}>;