@nx/devkit 23.2.0-beta.11 → 23.2.0-beta.12

package/dist/src/generators/target-defaults-utils.d.ts

@@ -34,6 +34,14 @@ export declare function upsertTargetDefault(tree: Tree, nxJson: NxJsonConfigurat
  * caller intended to find a specific entry but forgot to populate the lookup.
  */
 export declare function findTargetDefault(targetDefaults: TargetDefaults | undefined, locator: Pick<TargetDefaultEntry, 'target' | 'executor' | 'projects' | 'plugin'>): TargetDefaultEntry | undefined;
+/**
+ * Shape-level test: whether a `targetDefaults` key is a plain target name
+ * rather than executor-shaped (`a:b`) or a glob. Executor strings are not
+ * required to contain `:`, so a plain-named key can still resolve as an
+ * executor key when some target's effective executor equals it; callers
+ * needing that guarantee must exclude executor collisions themselves.
+ */
+export declare function isExactTargetNameKey(key: string): boolean;
 /**
  * The subset of a project graph node that the `projects` narrowing reads —
  * names come from the map keys, `root`/`tags` drive `findMatchingProjects`.

package/dist/src/generators/target-defaults-utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertTargetDefault = upsertTargetDefault;
 exports.findTargetDefault = findTargetDefault;
+exports.isExactTargetNameKey = isExactTargetNameKey;
 exports.updateTargetDefault = updateTargetDefault;
 exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
 exports.addBuildTargetDefaults = addBuildTargetDefaults;
@@ -219,13 +220,24 @@ function* logicalTargetDefaultEntries(targetDefaults) {
 // keys win), and such target names are vanishingly rare — accepted rather than
 // worked around.
 const GLOB_CHARACTERS = new Set(['*', '|', '{', '}', '(', ')', '[']);
-function isExecutorLikeKey(key) {
-    if (!key.includes(':'))
-        return false;
+function hasGlobCharacter(key) {
     for (const c of key)
         if (GLOB_CHARACTERS.has(c))
-            return false;
-    return true;
+            return true;
+    return false;
+}
+function isExecutorLikeKey(key) {
+    return key.includes(':') && !hasGlobCharacter(key);
+}
+/**
+ * Shape-level test: whether a `targetDefaults` key is a plain target name
+ * rather than executor-shaped (`a:b`) or a glob. Executor strings are not
+ * required to contain `:`, so a plain-named key can still resolve as an
+ * executor key when some target's effective executor equals it; callers
+ * needing that guarantee must exclude executor collisions themselves.
+ */
+function isExactTargetNameKey(key) {
+    return !key.includes(':') && !hasGlobCharacter(key);
 }
 /**
  * Walk the `targetDefaults` entries matching `context` and run `callback`

package/dist/src/utils/config-utils.d.ts

@@ -1,5 +1,8 @@
 export declare let dynamicImport: Function;
 export declare function loadConfigFile<T extends object = any>(configFilePath: string, tsconfigFileNames?: string[]): Promise<T>;
+export declare function isTranspilerRecoverableError(err: unknown, path: string): boolean;
+export declare function clearConfigFromRequireCache(rootId: string, cache?: NodeJS.Dict<NodeModule>): void;
+export declare function unwrapCjsInterop(path: string, module: unknown, cache?: NodeJS.Dict<NodeModule>): unknown;
 export declare function getRootTsConfigPath(): string | null;
 export declare function getRootTsConfigFileName(): string | null;
 export declare function clearRequireCache(): void;

package/dist/src/utils/config-utils.js

@@ -2,11 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dynamicImport = void 0;
 exports.loadConfigFile = loadConfigFile;
+exports.isTranspilerRecoverableError = isTranspilerRecoverableError;
+exports.clearConfigFromRequireCache = clearConfigFromRequireCache;
+exports.unwrapCjsInterop = unwrapCjsInterop;
 exports.getRootTsConfigPath = getRootTsConfigPath;
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
 exports.clearRequireCache = clearRequireCache;
 const fs_1 = require("fs");
 const node_url_1 = require("node:url");
+const node_util_1 = require("node:util");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
 const path_1 = require("path");
@@ -27,8 +31,22 @@ function isTypeScriptFile(extension) {
 }
 async function loadTypeScriptModule(path, extension, tsconfigFileNames) {
     const tsConfigPath = getTypeScriptConfigPath(path, tsconfigFileNames);
+    const modulePath = resolveModulePath(path);
     if (!tsConfigPath) {
-        return await loadModuleByExtension(path, extension);
+        // The tsconfig-less path needs the same ESM-registry routing as below:
+        // require() of a sync-ESM .ts serves the stale registry entry on reloads.
+        if (esmRegistryPaths.has(modulePath)) {
+            // Clear first so an ESM-to-CJS rewrite re-evaluates instead of the
+            // import() serving the cached require.cache entry.
+            clearConfigFromRequireCache(modulePath);
+            return unwrapCjsInterop(path, await loadESM(path));
+        }
+        clearConfigFromRequireCache(modulePath);
+        const result = await loadModuleByExtension(path, extension);
+        if (node_util_1.types.isModuleNamespaceObject(result)) {
+            esmRegistryPaths.add(modulePath);
+        }
+        return result;
     }
     // loadTsFile was added in nx@23. @nx/devkit's peer range supports older
     // nx majors, so fall back to the legacy registerTsProject + require path
@@ -42,57 +60,202 @@ async function loadTypeScriptModule(path, extension, tsconfigFileNames) {
             cleanup();
         }
     }
+    // require.cache busting cannot invalidate a module the ESM registry
+    // holds; reloads of known-ESM paths need a cache-busted import().
+    if (esmRegistryPaths.has(modulePath)) {
+        return await loadTsFileViaImport(path, tsConfigPath);
+    }
+    // A CJS-shaped .ts stays in require.cache and may have changed on disk
+    // since; clear it so the reload re-reads the file.
+    clearConfigFromRequireCache(modulePath);
     // Both .ts and .mts go through loadTsFile first. Node 22.12+ supports
     // require() of synchronous ESM by default, and loadTsFile's lazy fallback
     // covers swc/ts-node + tsconfig-paths registration when needed (swc-node
     // hooks .cts/.mts/.ts via Module._extensions). Async-only ESM modules
     // (top-level await) throw ERR_REQUIRE_ASYNC_MODULE and fall through to
-    // dynamic import(). ERR_REQUIRE_ESM is the legacy code for the same case
-    // - kept for older Node lines.
+    // dynamic import(). ERR_REQUIRE_ESM is the legacy code for the same case,
+    // kept for older Node lines.
     try {
-        return (0, devkit_internals_1.loadTsFile)(path, tsConfigPath);
+        const result = (0, devkit_internals_1.loadTsFile)(path, tsConfigPath);
+        if (node_util_1.types.isModuleNamespaceObject(result)) {
+            esmRegistryPaths.add(modulePath);
+        }
+        return result;
     }
     catch (e) {
         if (e?.code !== 'ERR_REQUIRE_ESM' &&
             e?.code !== 'ERR_REQUIRE_ASYNC_MODULE') {
             throw e;
         }
-        // The module must be loaded via dynamic import(). Register
-        // tsconfig-paths first so workspace alias imports resolve, then try a
-        // native dynamic import. Node 22.18+ LTS strips TS types on the ESM
-        // path natively, so pure-ESM TLA configs load without any swc/ts-node
-        // ESM loader. Only escalate to forceRegisterEsmLoader (which throws
-        // when neither @swc-node/register nor ts-node is installed) if the
-        // native attempt hits unsupported TS syntax.
+        return await loadTsFileViaImport(path, tsConfigPath);
+    }
+}
+// Resolved paths of configs that require() loaded as synchronous ESM;
+// reloads of these route through a cache-busted import(). On globalThis so the
+// state survives clearRequireCache evicting this module itself (a
+// workspace-linked devkit resolves outside node_modules).
+const esmRegistryPaths = (globalThis[Symbol.for('@nx/devkit:esmRegistryPaths')] ??= new Set());
+// Error codes from the load machinery (resolution, type stripping) that
+// warrant registering swc/ts-node + tsconfig-paths and importing again.
+// Unlisted errors propagate unchanged so a failing config is not
+// re-evaluated. A not-found error can also come from the config's own
+// dynamic import()/require() of a missing module, in which case the retry
+// re-runs its top-level side effects; accepted so that static alias and
+// extensionless imports (which fail at link time, before any user code
+// runs) stay recoverable.
+const ESM_LOAD_FALLBACK_ERROR_CODES = new Set([
+    'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX',
+    'ERR_MODULE_NOT_FOUND',
+    'MODULE_NOT_FOUND',
+    'ERR_UNKNOWN_FILE_EXTENSION',
+]);
+// Code-less errors that loadTsFile recovers on first load via the swc/
+// ts-node fallback: a CJS-only global (__dirname, __filename, require) or a
+// type-only named import evaluated on the native ESM path. Reloads must
+// recover them too or an edit that introduces one turns into a hard graph
+// failure. Prefer the host nx's classifiers so the gate matches what its
+// loadTsFile recovers; nx versions that support the error classes without
+// re-exporting the classifiers fall back to local replicas of them.
+function isTranspilerRecoverableError(err, path) {
+    return ((typeof devkit_internals_1.isRequireInEsmScopeError === 'function'
+        ? (0, devkit_internals_1.isRequireInEsmScopeError)(err, path)
+        : isRequireInEsmScopeErrorReplica(err, path)) ||
+        (typeof devkit_internals_1.isTsEsmNamedExportLinkageError === 'function'
+            ? (0, devkit_internals_1.isTsEsmNamedExportLinkageError)(err, path)
+            : isTsEsmNamedExportLinkageErrorReplica(err, path)));
+}
+function isRequireInEsmScopeErrorReplica(err, filePath) {
+    if (!(err instanceof ReferenceError)) {
+        return false;
+    }
+    if (!(filePath.endsWith('.ts') || filePath.endsWith('.mts'))) {
+        return false;
+    }
+    return /(require|__dirname|__filename) is not defined/.test(err.message);
+}
+function isTsEsmNamedExportLinkageErrorReplica(err, filePath) {
+    if (!(err instanceof SyntaxError)) {
+        return false;
+    }
+    return ((filePath.endsWith('.ts') || filePath.endsWith('.mts')) &&
+        err.message.includes('does not provide an export named'));
+}
+// Invalidates a config module and its local CommonJS dependency subtree,
+// leaving unrelated cached modules untouched (a broad clear re-evaluates
+// them and breaks singleton identity). Walks each module's recorded
+// children AND the cache-current instance for the same id, since another
+// config may retain an older instance of a shared dependency. Detaches the
+// root from its requiring parent so repeated reloads don't accumulate
+// Module objects in the parent's children array.
+function clearConfigFromRequireCache(rootId, cache = require.cache) {
+    const root = cache[rootId];
+    if (!root) {
+        return;
+    }
+    const visited = new Set();
+    const idsToDelete = new Set();
+    const queue = [root];
+    while (queue.length) {
+        const mod = queue.pop();
+        if (!mod || visited.has(mod)) {
+            continue;
+        }
+        visited.add(mod);
+        if (packageInstallationDirectories.some((dir) => mod.id.includes(dir))) {
+            continue;
+        }
+        idsToDelete.add(mod.id);
+        const current = cache[mod.id];
+        if (current && current !== mod) {
+            queue.push(current);
+        }
+        for (const child of mod.children) {
+            queue.push(child);
+        }
+    }
+    for (const id of idsToDelete) {
+        delete cache[id];
+    }
+    if (root.parent) {
+        root.parent.children = root.parent.children.filter((child) => child.id !== rootId);
+    }
+}
+// Canonical key for require.cache checks and esmRegistryPaths: a symlinked
+// config's caller path differs from require's resolved filename.
+function resolveModulePath(path) {
+    try {
+        return require.resolve(path);
+    }
+    catch {
+        return path;
+    }
+}
+async function loadTsFileViaImport(path, tsConfigPath) {
+    // Clear any prior require.cache entry so an ESM-to-CJS rewrite (or a
+    // loader-classified CJS load) re-evaluates instead of serving the cached
+    // copy.
+    clearConfigFromRequireCache(resolveModulePath(path));
+    // Try a bare native import first: Node 22.18+ strips TS types on the ESM
+    // path natively, and registerTsProject must NOT run up front. A
+    // registered swc/ts-node ESM loader intercepts every subsequent import
+    // in the process (it cannot be unregistered) and may classify a .ts
+    // config as CommonJS, defeating loadESM's cache-busting query on
+    // reloads. Register only when the native attempt fails.
+    try {
+        return unwrapCjsInterop(path, await loadESM(path));
+    }
+    catch (esmErr) {
+        if (!ESM_LOAD_FALLBACK_ERROR_CODES.has(esmErr?.code) &&
+            !isTranspilerRecoverableError(esmErr, path)) {
+            throw esmErr;
+        }
         const cleanup = (0, devkit_internals_1.registerTsProject)(tsConfigPath);
         try {
-            return await loadESM(path);
+            return unwrapCjsInterop(path, await loadESM(path));
         }
-        catch (esmErr) {
-            if (esmErr?.code !== 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' ||
+        catch (retryErr) {
+            if (isTranspilerRecoverableError(retryErr, path)) {
+                // A registered swc ESM loader compiles the retry to CJS, but
+                // ts-node/esm keeps the file ESM, so CJS globals stay undefined on
+                // the import path. Route through the CJS transpiler hook
+                // registerTsProject installed; it reads fresh from disk. A
+                // namespace result means no hook intercepted and require() hit the
+                // stale ESM registry, so surface the error instead.
+                const required = require(path);
+                if (!node_util_1.types.isModuleNamespaceObject(required)) {
+                    return required;
+                }
+                throw retryErr;
+            }
+            if (retryErr?.code !== 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' ||
                 typeof devkit_internals_1.forceRegisterEsmLoader !== 'function') {
-                throw esmErr;
+                throw retryErr;
             }
-            // Module.register is global and one-shot per process. After this
-            // runs, every subsequent ESM import in the process is routed
-            // through the registered loader, forfeiting Node's native TS
-            // stripping for the dynamic-import path. If neither swc-node nor
-            // ts-node is installed, forceRegisterEsmLoader throws - surface the
-            // original ESM error in that case so the user sees the real
-            // problem, not a misleading "loader missing" message.
+            // Loader registration cannot be undone. Preserve the import error
+            // if registration itself fails.
             try {
                 (0, devkit_internals_1.forceRegisterEsmLoader)();
             }
             catch {
-                throw esmErr;
+                throw retryErr;
             }
-            return await loadESM(path);
+            return unwrapCjsInterop(path, await loadESM(path));
         }
         finally {
             cleanup();
         }
     }
 }
+// Some loaders emit CJS for a dynamic import, wrapping module.exports in
+// namespace.default (the __esModule marker is optional), so cache identity is
+// the discriminator: a require(esm) entry holds the namespace itself, and the
+// entry check stops a default-less namespace from matching undefined.
+function unwrapCjsInterop(path, module, cache = require.cache) {
+    const entry = cache[resolveModulePath(path)];
+    const cjsExports = module
+        ?.default;
+    return entry && entry.exports === cjsExports ? cjsExports : module;
+}
 function getTypeScriptConfigPath(path, tsconfigFileNames) {
     const siblingFiles = (0, fs_1.readdirSync)((0, path_1.dirname)(path));
     const tsConfigFileName = (tsconfigFileNames ?? ['tsconfig.json']).find((name) => siblingFiles.includes(name));
@@ -147,7 +310,7 @@ async function load(path) {
         return await loadCommonJS(path);
     }
     catch (e) {
-        if (e.code === 'ERR_REQUIRE_ESM') {
+        if (['ERR_REQUIRE_ESM', 'ERR_REQUIRE_ASYNC_MODULE'].includes(e.code)) {
             // If `require` fails to load ESM, try dynamic `import()`. ESM requires file url protocol for handling absolute paths.
             return loadESM(path);
         }
@@ -165,7 +328,14 @@ async function loadCommonJS(path) {
     }
     return require(path);
 }
+// Global monotonic counter (not Date.now()) so two reloads never share a
+// cache-busting URL, across same-millisecond loads, module reloads, and
+// devkit copies.
+const esmLoadState = (globalThis[Symbol.for('@nx/devkit:esmLoadState')] ??= { count: 0 });
 async function loadESM(path) {
-    const pathAsFileUrl = (0, node_url_1.pathToFileURL)(path).pathname;
-    return await (0, exports.dynamicImport)(`${pathAsFileUrl}?t=${Date.now()}`);
+    // Keep the full file URL (.pathname would drop a UNC authority); the
+    // unique query gives each reload a fresh ESM registry key.
+    const fileUrl = (0, node_url_1.pathToFileURL)(path);
+    fileUrl.searchParams.set('t', (esmLoadState.count++).toString());
+    return await (0, exports.dynamicImport)(fileUrl.href);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "23.2.0-beta.11",
+  "version": "23.2.0-beta.12",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -67,7 +67,7 @@
   },
   "devDependencies": {
     "jest": "30.3.0",
-    "nx": "23.2.0-beta.11"
+    "nx": "23.2.0-beta.12"
   },
   "peerDependencies": {
     "nx": ">= 22 <= 24 || ^23.0.0-0"