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

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,19 @@ 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. Only composite configs are exempt — their
+ * `rootDir` defaults to the tsconfig directory in both versions regardless of
+ * the file set.
  *
  * 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`).
+ * `extends` base: a composite child would inherit the new value and shift its
+ * emit layout, so each such child is pinned to its own directory to block it.
+ * 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,20 @@ 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. Only composite configs are exempt — their
+ * `rootDir` defaults to the tsconfig directory in both versions regardless of
+ * the file set.
  *
  * 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`).
+ * `extends` base: a composite child would inherit the new value and shift its
+ * emit layout, so each such child is pinned to its own directory to block it.
+ * Runs only on TypeScript 6 workspaces (gated by `requires`).
  */
 async function default_1(tree) {
     tsModule ??= (0, ensure_typescript_1.ensureTypescript)();
@@ -60,8 +64,8 @@ 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
+    // Phase 3: shield composite 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
@@ -78,7 +82,7 @@ async function default_1(tree) {
     while (added) {
         added = false;
         for (const c of candidates) {
-            if (c.analysis.kind !== 'own-dir' || shielded.has(c.relPath)) {
+            if (c.analysis.kind !== 'composite' || shielded.has(c.relPath)) {
                 continue;
             }
             if (inheritsRootDir(ts, treeParseHost, readFile, c.relPath)) {
@@ -107,25 +111,27 @@ function analyze(ts, absPath, parseConfigHost) {
         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.
+    // 5.x and 6.0, so the 6.0 change leaves it alone. Never pin a file-derived
+    // value; only shield it from a `rootDir` this migration pins on an `extends`
+    // base.
     if (options.composite) {
-        return { kind: 'own-dir' };
+        return { kind: 'composite' };
     }
     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.
+// True when TypeScript resolves an inherited `rootDir` for the config. A
+// composite config sets none of its own (or it would be `has-rootDir`), 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) {
@@ -203,13 +209,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,9 @@
 
 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`), ones with no input files, and composite projects (whose `rootDir` defaults to the tsconfig directory in both versions, for any file subset). 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.
+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: a composite child would inherit the new value and emit to the wrong place, so each such child is pinned to its own directory to keep the default it had.
 
 #### 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.1",
+      "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 not given an inferred `rootDir`, since it already defaults to the tsconfig directory in both versions; a composite that extends a base receiving a pinned `rootDir` is itself pinned to its own directory to preserve that default.",
       "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.1",
   "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.1",
+    "@nx/workspace": "23.1.0-rc.1"
   },
   "devDependencies": {
-    "nx": "23.1.0-rc.0"
+    "nx": "23.1.0-rc.1"
   },
   "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);
-}