@nx/js 23.1.0-rc.0 → 23.1.0-rc.2

package/dist/src/executors/node/node.impl.js

@@ -11,7 +11,7 @@ const crypto_1 = require("crypto");
 const path = tslib_1.__importStar(require("path"));
 const path_1 = require("path");
 const buildable_libs_utils_1 = require("../../utils/buildable-libs-utils");
-const kill_tree_1 = require("./lib/kill-tree");
+const native_1 = require("nx/src/native");
 const line_aware_writer_1 = require("./lib/line-aware-writer");
 const coalescing_debounce_1 = require("./lib/coalescing-debounce");
 const fileutils_1 = require("nx/src/utils/fileutils");
@@ -67,23 +67,26 @@ async function* nodeExecutor(options, context) {
             const previousTask = currentTask;
             const task = tasks.shift();
             if (previousTask && !previousTask.killed) {
-                previousTask.killed = true;
-                if (previousTask.childProcess?.connected) {
-                    previousTask.childProcess.disconnect();
-                }
-                previousTask.childProcess?.removeAllListeners();
+                // stop() marks the task killed, detaches listeners, and waits for the
+                // process tree to exit.
                 await previousTask.stop('SIGTERM');
                 await new Promise((resolve) => setImmediate(resolve));
             }
             currentTask = task;
             globalLineAwareWriter.setActiveProcess(task.id);
             await task.start();
+            // A file change may have queued another task while we waited for the
+            // previous process to stop. Its debounce trigger piggybacked on this
+            // in-flight run, so drain the queue now or it would sit unprocessed
+            // until the next change.
+            if (tasks.length > 0) {
+                await processQueue();
+            }
         };
         const debouncedProcessQueue = (0, coalescing_debounce_1.createCoalescingDebounce)(processQueue, options.debounce ?? 1_000);
         const addToQueue = async (childProcess, buildResult) => {
             for (const task of tasks) {
                 if (!task.killed) {
-                    task.killed = true;
                     await task.stop('SIGTERM');
                 }
             }
@@ -156,7 +159,7 @@ async function* nodeExecutor(options, context) {
                 },
                 stop: async (signal = 'SIGTERM') => {
                     task.killed = true;
-                    if (task.childProcess) {
+                    if (task.childProcess?.pid) {
                         if (task.childProcess.stdout) {
                             task.childProcess.stdout.pause();
                         }
@@ -167,7 +170,12 @@ async function* nodeExecutor(options, context) {
                             task.childProcess.disconnect();
                         }
                         task.childProcess.removeAllListeners();
-                        await (0, kill_tree_1.killTree)(task.childProcess.pid, signal);
+                        // Wait for the process tree to fully exit so the port is released
+                        // before a watch-mode restart boots the next server (EADDRINUSE).
+                        // Windows cannot deliver graceful signals through this API, so
+                        // skip the grace period and force-kill immediately (matching the
+                        // previous taskkill /F behavior).
+                        await (0, native_1.killProcessTreeGraceful)(task.childProcess.pid, signal, process.platform === 'win32' ? 0 : undefined);
                     }
                     if (task.id === globalLineAwareWriter.currentProcessId) {
                         globalLineAwareWriter.setActiveProcess(null);

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.d.ts

@@ -12,15 +12,25 @@ import { type Tree } from '@nx/devkit';
  * compilation and emit layout are unchanged under 6.0. The value is computed by
  * the compiler itself: a throwaway program built with `configFilePath` cleared
  * takes the file-derived branch of `getCommonSourceDirectory`, so it matches
- * `tsc` exactly, including project-reference redirects. Configs already at the
- * 6.0 default are left untouched: their inferred directory equals the tsconfig
- * directory, or they are composite (which defaulted there before 6.0 too).
+ * `tsc` exactly, including project-reference redirects. The pin is written even
+ * when the inferred directory already equals the tsconfig directory: inference
+ * is per-program, and tools like ts-jest's `isolatedModules` compile single
+ * files against the same config, collapsing the common directory below the
+ * config dir and failing with TS5011.
+ *
+ * Composite configs are pinned too, to the tsconfig's own directory. Under `tsc`
+ * a composite `rootDir` already defaults there (for any file subset), so `"."`
+ * is a no-op — but ts-jest strips `composite` for its per-file transpile, and
+ * TypeScript 6 only exempts genuinely-composite programs from the containment
+ * check (`!options.composite`), so a composite spec config compiled by ts-jest
+ * hits TS5011 all the same. The explicit `"."` survives the strip. Pinning the
+ * own directory (not a deeper file-derived value) keeps a real composite build's
+ * emit layout unchanged.
  *
  * Each config is written on its own; nothing is written to a shared `extends`
- * base, so a config never inherits a `rootDir` computed for a sibling. The one
- * case that needs care is a config that both needs a `rootDir` and is itself an
- * `extends` base: its own-directory children would inherit the new value and
- * shift their emit layout, so each such child is pinned to its own directory to
- * block it. Runs only on TypeScript 6 workspaces (gated by `requires`).
+ * base, so a config never inherits a `rootDir` computed for a sibling — and
+ * because every config that emits is given its own explicit `rootDir`, none
+ * inherits a value pinned on a base. Runs only on TypeScript 6 workspaces
+ * (gated by `requires`).
  */
 export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.js

@@ -22,16 +22,26 @@ let tsModule;
  * compilation and emit layout are unchanged under 6.0. The value is computed by
  * the compiler itself: a throwaway program built with `configFilePath` cleared
  * takes the file-derived branch of `getCommonSourceDirectory`, so it matches
- * `tsc` exactly, including project-reference redirects. Configs already at the
- * 6.0 default are left untouched: their inferred directory equals the tsconfig
- * directory, or they are composite (which defaulted there before 6.0 too).
+ * `tsc` exactly, including project-reference redirects. The pin is written even
+ * when the inferred directory already equals the tsconfig directory: inference
+ * is per-program, and tools like ts-jest's `isolatedModules` compile single
+ * files against the same config, collapsing the common directory below the
+ * config dir and failing with TS5011.
+ *
+ * Composite configs are pinned too, to the tsconfig's own directory. Under `tsc`
+ * a composite `rootDir` already defaults there (for any file subset), so `"."`
+ * is a no-op — but ts-jest strips `composite` for its per-file transpile, and
+ * TypeScript 6 only exempts genuinely-composite programs from the containment
+ * check (`!options.composite`), so a composite spec config compiled by ts-jest
+ * hits TS5011 all the same. The explicit `"."` survives the strip. Pinning the
+ * own directory (not a deeper file-derived value) keeps a real composite build's
+ * emit layout unchanged.
  *
  * Each config is written on its own; nothing is written to a shared `extends`
- * base, so a config never inherits a `rootDir` computed for a sibling. The one
- * case that needs care is a config that both needs a `rootDir` and is itself an
- * `extends` base: its own-directory children would inherit the new value and
- * shift their emit layout, so each such child is pinned to its own directory to
- * block it. Runs only on TypeScript 6 workspaces (gated by `requires`).
+ * base, so a config never inherits a `rootDir` computed for a sibling — and
+ * because every config that emits is given its own explicit `rootDir`, none
+ * inherits a value pinned on a base. Runs only on TypeScript 6 workspaces
+ * (gated by `requires`).
  */
 async function default_1(tree) {
     tsModule ??= (0, ensure_typescript_1.ensureTypescript)();
@@ -50,7 +60,10 @@ async function default_1(tree) {
             analysis: analyze(ts, absPath, parseConfigHost),
         };
     });
-    // Phase 2: pin each config that needs a `rootDir` on its own.
+    // Phase 2: pin each config that needs a `rootDir` on its own. Every config
+    // that emits is given its own explicit value here — including composites,
+    // pinned to their own directory — so none is left to inherit a `rootDir` this
+    // migration pins on a base.
     let changed = 0;
     for (const c of candidates) {
         if (c.analysis.kind === 'write') {
@@ -60,36 +73,6 @@ async function default_1(tree) {
             }
         }
     }
-    // Phase 3: shield own-dir configs that now inherit a pinned `rootDir` from a
-    // base. Re-parse each from the tree (so Phase 2's writes are visible); when
-    // TypeScript reports an inherited `rootDir` where there was none, pin the
-    // config to its own directory so its emit layout does not shift. Repeat until
-    // stable, since shielding one config can turn it into a base for another. The
-    // tree-backed host lets TypeScript resolve `extends`; the `readDirectory`
-    // no-op skips the unused file scan.
-    const readFile = (filePath) => tree.read(filePath, 'utf-8') ?? undefined;
-    const treeParseHost = {
-        ...ts.sys,
-        readFile,
-        readDirectory: () => [],
-    };
-    const shielded = new Set();
-    let added = true;
-    while (added) {
-        added = false;
-        for (const c of candidates) {
-            if (c.analysis.kind !== 'own-dir' || shielded.has(c.relPath)) {
-                continue;
-            }
-            if (inheritsRootDir(ts, treeParseHost, readFile, c.relPath)) {
-                if (setRootDir(tree, c.relPath, '.')) {
-                    changed++;
-                }
-                shielded.add(c.relPath);
-                added = true;
-            }
-        }
-    }
     if (changed > 0) {
         await (0, devkit_1.formatFiles)(tree);
     }
@@ -106,34 +89,26 @@ function analyze(ts, absPath, parseConfigHost) {
     if (!setsEmitGate(options) || fileNames.length === 0) {
         return { kind: 'inert' };
     }
-    // Composite already defaults `rootDir` to the tsconfig's own directory in both
-    // 5.x and 6.0, so the 6.0 change leaves it alone. Treat it as own-dir: never
-    // pin a file-derived value, and shield it from a `rootDir` this migration pins
-    // on an `extends` base.
+    // Composite: pin the tsconfig's own directory, not a file-derived value.
+    // `rootDir` already defaults there under `tsc`, so `"."` preserves a real
+    // composite build's emit layout — but ts-jest strips `composite` for its
+    // per-file transpile, and TS6 only skips the containment check for genuinely
+    // composite programs, so an unpinned composite spec config still fails with
+    // TS5011 under ts-jest. The explicit pin survives the strip.
     if (options.composite) {
-        return { kind: 'own-dir' };
+        return { kind: 'write', dirAbs: toPosix((0, node_path_1.dirname)(absPath)) };
     }
     const commonDir = computeCommonSourceDirectory(ts, fileNames, options, projectReferences);
     if (!commonDir) {
         return { kind: 'inert' };
     }
-    if (equalPaths(ts, commonDir, (0, node_path_1.dirname)(absPath))) {
-        return { kind: 'own-dir' };
-    }
+    // Written even when `commonDir` is the tsconfig's own directory (the 6.0
+    // default): a tool compiling a subset of the config's files — ts-jest with
+    // `isolatedModules` builds a program per test file — re-infers the common
+    // directory from that subset alone, and without an explicit `rootDir` TS6
+    // fails with TS5011.
     return { kind: 'write', dirAbs: toPosix(commonDir).replace(/\/+$/, '') };
 }
-// True when TypeScript resolves an inherited `rootDir` for the config. An own-dir
-// config sets none of its own, so any `rootDir` reported here comes from a base
-// this migration just pinned, and inheriting it would shift the config's emit
-// layout.
-function inheritsRootDir(ts, parseHost, readFile, relPath) {
-    const config = ts.readConfigFile(relPath, readFile).config;
-    if (!config) {
-        return false;
-    }
-    const { options } = ts.parseJsonConfigFileContent(config, parseHost, (0, node_path_1.dirname)(relPath));
-    return options.rootDir != null;
-}
 // Any of these makes TypeScript run the source-file containment / common-source
 // computation that emits TS5011 / TS6059 when `rootDir` is absent.
 function setsEmitGate(o) {
@@ -203,13 +178,6 @@ function toRelativeRootDir(tsconfigDir, commonDir) {
     const rel = node_path_1.posix.relative(toPosix(tsconfigDir), toPosix(commonDir));
     return rel === '' ? '.' : rel;
 }
-function equalPaths(ts, a, b) {
-    const normalize = (p) => {
-        const stripped = toPosix(p).replace(/\/+$/, '');
-        return ts.sys.useCaseSensitiveFileNames ? stripped : stripped.toLowerCase();
-    };
-    return normalize(a) === normalize(b);
-}
 function toPosix(p) {
     return p.split('\\').join('/');
 }

package/dist/src/migrations/update-23-1-0/set-tsconfig-root-dir-for-ts6.md

@@ -2,9 +2,11 @@
 
 Before TypeScript 6, a tsconfig that did not set `rootDir` had it inferred as the common directory of the program's non-declaration input files. TypeScript 6 changed that default to the tsconfig's own directory. A program whose files resolve outside that directory (most commonly a spec or e2e tsconfig that imports another project's source through a `paths` alias) now hard-fails with `TS5011` or `TS6059` because a file falls outside the assumed root.
 
-For every project `tsconfig*.json` that does not already set `rootDir` (directly or through `extends`), this migration pins `rootDir` to exactly the directory TypeScript 5 would have inferred, so both compilation and emit layout stay the same under TypeScript 6. The value is computed by the TypeScript compiler itself, so it matches `tsc` exactly, including project-reference redirects. Configs that cannot hit the error are skipped: ones without an output option (`outDir`, `outFile`, `sourceRoot`, `mapRoot`, or `declaration` + `declarationDir`), ones with no input files, composite projects (whose `rootDir` already defaulted to the tsconfig directory before TypeScript 6), and ones whose inferred directory already equals the tsconfig directory. The migration only runs when the workspace is on TypeScript 6.
+For every project `tsconfig*.json` that does not already set `rootDir` (directly or through `extends`), this migration pins `rootDir` to exactly the directory TypeScript 5 would have inferred, so both compilation and emit layout stay the same under TypeScript 6. The value is computed by the TypeScript compiler itself, so it matches `tsc` exactly, including project-reference redirects. The pin is written even when the inferred directory already equals the tsconfig directory: inference is per-program, and a tool that compiles a subset of the config's files — ts-jest with `isolatedModules` builds a program per test file — re-infers a deeper common directory from that subset and fails with `TS5011`. Configs that cannot hit the error are skipped: ones without an output option (`outDir`, `outFile`, `sourceRoot`, `mapRoot`, or `declaration` + `declarationDir`), and ones with no input files. The migration only runs when the workspace is on TypeScript 6.
 
-Each config is updated on its own; the migration never writes `rootDir` to a shared `extends` base, so a config never inherits a value computed for a sibling. The one case that needs care is a config that both needs a `rootDir` and is itself an `extends` base: its self-contained children would inherit the new value and emit to the wrong place, so each such child is pinned to its own directory to keep its layout. This includes a composite child, whose own-directory default would otherwise be overridden by the inherited value.
+Composite projects are pinned to their own directory (`"."`). Under `tsc` a composite `rootDir` already defaults there, so the pin is a no-op for a real composite build — but ts-jest strips `composite` for its per-file transpile, and TypeScript 6 only exempts genuinely-composite programs from the containment check, so a composite spec config compiled by ts-jest still fails with `TS5011` without an explicit `rootDir`. Pinning the own directory (rather than a deeper file-derived value) keeps the composite build's emit layout unchanged while fixing the ts-jest case.
+
+Each config is updated on its own; the migration never writes `rootDir` to a shared `extends` base, so a config never inherits a value computed for a sibling. Because every config that emits is given its own explicit `rootDir`, none is left to inherit a value pinned on a base.
 
 #### Sample Code Changes
 

package/migrations.json

@@ -39,8 +39,8 @@
       "documentation": "./dist/src/migrations/update-23-1-0/add-ignore-deprecations-for-ts6.md"
     },
     "23-1-0-set-tsconfig-root-dir-for-ts6": {
-      "version": "23.1.0-beta.8",
-      "description": "Sets an explicit `rootDir` on project `tsconfig*.json` files that lack one, pinned to the source directory TypeScript 5 inferred implicitly, so programs whose input files span more than one directory (for example a spec tsconfig importing another project's source through a `paths` alias) keep compiling under TypeScript 6, which otherwise hard-fails with TS5011 or TS6059. The value is computed by the compiler, so emit layout is unchanged. Each config is written on its own; the migration never writes to a shared `extends` base, so a config never inherits a value computed for a sibling. Composite projects are not given an inferred `rootDir`, since it already defaulted to the tsconfig directory before TypeScript 6; a composite that extends a base receiving a pinned `rootDir` is itself pinned to its own directory to preserve that default.",
+      "version": "23.1.0-rc.2",
+      "description": "Sets an explicit `rootDir` on project `tsconfig*.json` files that lack one, pinned to the source directory TypeScript 5 inferred implicitly, so programs keep compiling and emitting the same layout under TypeScript 6, which otherwise hard-fails with TS5011 or TS6059 (for example a spec tsconfig importing another project's source through a `paths` alias). The pin is written even when the inferred directory already equals the tsconfig directory, because tools like ts-jest with `isolatedModules` compile a program per file and re-infer a deeper directory from that subset. The value is computed by the compiler, so emit layout is unchanged. Each config is written on its own; the migration never writes to a shared `extends` base, so a config never inherits a value computed for a sibling. Composite projects are pinned to their own directory: `rootDir` already defaults there under `tsc` so it is a no-op for a real composite build, but ts-jest strips `composite` for its per-file transpile and the explicit value is needed to avoid TS5011 there.",
       "requires": {
         "typescript": ">=6.0.0"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.1.0-rc.0",
+  "version": "23.1.0-rc.2",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -144,11 +144,11 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/workspace": "23.1.0-rc.0",
-    "@nx/devkit": "23.1.0-rc.0"
+    "@nx/devkit": "23.1.0-rc.2",
+    "@nx/workspace": "23.1.0-rc.2"
   },
   "devDependencies": {
-    "nx": "23.1.0-rc.0"
+    "nx": "23.1.0-rc.2"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",

package/dist/src/executors/node/lib/kill-tree.d.ts

@@ -1 +0,0 @@
-export declare function killTree(pid: number, signal: NodeJS.Signals): Promise<void>;

package/dist/src/executors/node/lib/kill-tree.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.killTree = killTree;
-// Adapted from https://raw.githubusercontent.com/pkrumins/node-tree-kill/deee138/index.js
-const child_process_1 = require("child_process");
-async function killTree(pid, signal) {
-    const tree = {};
-    const pidsToProcess = {};
-    tree[pid] = [];
-    pidsToProcess[pid] = 1;
-    return new Promise((resolve, reject) => {
-        const callback = (error) => {
-            if (error) {
-                reject(error);
-            }
-            else {
-                resolve();
-            }
-        };
-        switch (process.platform) {
-            case 'win32':
-                (0, child_process_1.exec)('taskkill /pid ' + pid + ' /T /F', {
-                    windowsHide: true,
-                }, (error) => {
-                    // Ignore Fatal errors (128) because it might be due to the process already being killed.
-                    // On Linux/Mac we can check ESRCH (no such process), but on Windows we can't.
-                    callback(error?.code !== 128 ? error : null);
-                });
-                break;
-            case 'darwin':
-                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                    return (0, child_process_1.spawn)('pgrep', ['-P', parentPid], {
-                        windowsHide: true,
-                    });
-                }, function () {
-                    killAll(tree, signal, callback);
-                });
-                break;
-            default: // Linux
-                buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
-                    return (0, child_process_1.spawn)('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid], {
-                        windowsHide: true,
-                    });
-                }, function () {
-                    killAll(tree, signal, callback);
-                });
-                break;
-        }
-    });
-}
-function killAll(tree, signal, callback) {
-    const killed = {};
-    try {
-        Object.keys(tree).forEach(function (pid) {
-            tree[pid].forEach(function (pidpid) {
-                if (!killed[pidpid]) {
-                    killPid(pidpid, signal);
-                    killed[pidpid] = 1;
-                }
-            });
-            if (!killed[pid]) {
-                killPid(pid, signal);
-                killed[pid] = 1;
-            }
-        });
-    }
-    catch (err) {
-        if (callback) {
-            return callback(err);
-        }
-        else {
-            throw err;
-        }
-    }
-    if (callback) {
-        return callback();
-    }
-}
-function killPid(pid, signal) {
-    try {
-        process.kill(parseInt(pid, 10), signal);
-    }
-    catch (err) {
-        if (err.code !== 'ESRCH')
-            throw err;
-    }
-}
-function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
-    const ps = spawnChildProcessesList(parentPid);
-    let allData = '';
-    ps.stdout.on('data', (data) => {
-        data = data.toString('ascii');
-        allData += data;
-    });
-    const onClose = function (code) {
-        delete pidsToProcess[parentPid];
-        if (code != 0) {
-            // no more parent processes
-            if (Object.keys(pidsToProcess).length == 0) {
-                cb();
-            }
-            return;
-        }
-        allData.match(/\d+/g).forEach((_pid) => {
-            const pid = parseInt(_pid, 10);
-            tree[parentPid].push(pid);
-            tree[pid] = [];
-            pidsToProcess[pid] = 1;
-            buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
-        });
-    };
-    ps.on('close', onClose);
-}