nx 23.3.0-beta.7 → 23.3.0-beta.9

package/dist/src/nx-cloud/utilities/url-shorten.js

@@ -5,10 +5,11 @@ exports.getURLifShortenFailed = getURLifShortenFailed;
 const logger_1 = require("../../utils/logger");
 const get_cloud_options_1 = require("./get-cloud-options");
 const git_utils_1 = require("../../utils/git-utils");
+const http_client_1 = require("../../utils/http-client");
 async function createNxCloudOnboardingURL(onboardingSource, accessToken, meta, forceManual = false, forceGithub = false, directory, 
 // Aborting tears down the in-flight request; without it a caller that stops
 // waiting (see prefetchRemoteCacheOnboardingUrl) leaves the socket holding
-// the event loop open, since axios has no default timeout.
+// the event loop open, since these requests have no timeout.
 signal) {
     const remoteInfo = (0, git_utils_1.getVcsRemoteInfo)(directory);
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
@@ -26,14 +27,18 @@ signal) {
     }
     const source = getSource(onboardingSource);
     try {
-        const response = await require('axios').post(`${apiUrl}/nx-cloud/onboarding`, {
-            type: usesGithub ? 'GITHUB' : 'MANUAL',
-            source,
-            accessToken: usesGithub ? null : accessToken,
-            selectedRepositoryName: remoteInfo?.slug ?? null,
-            repositoryDomain: remoteInfo?.domain ?? null,
-            meta,
-        }, { signal });
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/onboarding`, {
+            method: 'POST',
+            data: {
+                type: usesGithub ? 'GITHUB' : 'MANUAL',
+                source,
+                accessToken: usesGithub ? null : accessToken,
+                selectedRepositoryName: remoteInfo?.slug ?? null,
+                repositoryDomain: remoteInfo?.domain ?? null,
+                meta,
+            },
+            signal,
+        });
         if (!response?.data || response.data.message) {
             throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
         }
@@ -69,7 +74,9 @@ function getURLifShortenFailed(usesGithub, githubSlug, apiUrl, source, accessTok
 }
 async function getInstallationSupportsGitHub(apiUrl, signal) {
     try {
-        const response = await require('axios').get(`${apiUrl}/nx-cloud/system/features`, { signal });
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/system/features`, {
+            signal,
+        });
         if (!response?.data || response.data.message) {
             throw new Error(response?.data?.message ?? 'Failed to shorten Nx Cloud URL');
         }

package/dist/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -416,17 +416,16 @@ class TargetProjectLocator {
         const packageJsonPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)((0, node_path_1.join)(packageName, 'package.json'), relativeToDir);
         if (packageJsonPath) {
             if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                return this.packageJsonResolutionCache.get(packageJsonPath);
+                const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                if (cached) {
+                    return cached;
+                }
             }
             const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
             if (parsedPackageJson.name && parsedPackageJson.version) {
                 this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
                 return parsedPackageJson;
             }
-            else {
-                this.packageJsonResolutionCache.set(packageJsonPath, null);
-                return null;
-            }
         }
         try {
             // Resolve the main entry point of the package
@@ -435,22 +434,27 @@ class TargetProjectLocator {
             while (dir !== (0, node_path_1.dirname)(dir)) {
                 const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
                 if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                    return this.packageJsonResolutionCache.get(packageJsonPath);
-                }
-                try {
-                    const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
-                    // Ensure the package.json contains the "name" and "version" fields
-                    if (parsedPackageJson.name && parsedPackageJson.version) {
-                        this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
-                        return parsedPackageJson;
+                    const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                    if (cached) {
+                        return cached;
                     }
-                    else {
+                    // Cached incomplete manifests are traversal points, not terminal misses.
+                }
+                else {
+                    try {
+                        const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+                        // Ensure the package.json contains the "name" and "version" fields
+                        if (parsedPackageJson.name && parsedPackageJson.version) {
+                            this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
+                            return parsedPackageJson;
+                        }
+                        // A module-format stub without name/version: remember it and keep
+                        // traversing towards the real manifest.
                         this.packageJsonResolutionCache.set(packageJsonPath, null);
-                        return null;
                     }
-                }
-                catch {
-                    // Package.json is invalid, keep traversing
+                    catch {
+                        // Package.json is invalid, keep traversing
+                    }
                 }
                 dir = (0, node_path_1.dirname)(dir);
             }

package/dist/src/plugins/js/utils/register.js

@@ -847,6 +847,13 @@ function loadTsFile(filePath, tsConfigPath) {
     if (isInvokedByTsx) {
         return require(filePath);
     }
+    // Executors and generators load in processes that never loaded a plugin
+    // (batch workers, forked tasks), so the NodeNext `.js` -> `.ts` resolvers the
+    // plugin loader installs are not there yet. Both are idempotent.
+    ensureCjsResolverPatched();
+    if (preferNodeStripTypes) {
+        ensureNodeNextEsmResolverRegistered();
+    }
     if (!preferNodeStripTypes) {
         if (!resolvedTsConfigPath) {
             throw new Error(`${logger_1.NX_PREFIX} loadTsFile could not find a workspace tsconfig while loading ${filePath} on the swc/ts-node path. Pass an explicit tsConfigPath or add a tsconfig.base.json/tsconfig.json at the workspace root.`);
@@ -859,9 +866,10 @@ function loadTsFile(filePath, tsConfigPath) {
             cleanup();
         }
     }
-    // Native strip path: no registration up front. pnpm/npm/yarn workspaces
-    // resolve aliases without tsconfig-paths. On failure, lazy-register what
-    // the specific error code indicates is needed and retry:
+    // Native strip path: no tsconfig-paths or transpiler registration up
+    // front. pnpm/npm/yarn workspaces resolve aliases without tsconfig-paths.
+    // On failure, lazy-register what the specific error code indicates is
+    // needed and retry:
     //   - MODULE_NOT_FOUND -> first try tsconfig-paths (alias resolution).
     //     If that still fails (e.g. extensionless `import './foo'` when
     //     `foo.ts` is adjacent - Node's resolver doesn't add `.ts`), escalate

package/dist/src/project-graph/affected/affected-reasons.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Why a task was considered affected.
+ *
+ * One open shape rather than a discriminated union, because the matches behind
+ * these cross the napi boundary as `#[napi(object)]` structs, which carry no
+ * tag. `kind` is the discriminant; the rest are populated per kind and absent
+ * otherwise.
+ *
+ * Reasons are collected flat: a task lists every reason that applies to it,
+ * and propagation is expressed by naming the producer rather than nesting its
+ * reasons, so the producer's own reasons are one lookup away in the same output.
+ */
+export type AffectedReasonKind = 
+/** A changed file matched one of the task's inputs. */
+'input-file'
+/** It reads the outputs of a task the change reached. */
+ | 'dependent-output'
+/** A project config the task hashes changed. */
+ | 'project-configuration'
+/** A project config no longer on disk, so every task was selected. */
+ | 'deleted-project-configuration'
+/** A package the task hashes moved, or the root package.json names its project. */
+ | 'npm-package'
+/** It hashes every external dependency, and one moved. */
+ | 'external-dependencies'
+/** A lockfile changed and `projectsAffectedByDependencyUpdates` names its project. */
+ | 'lockfile'
+/** A dependency change could not be pinned to packages, so a whole ecosystem moved. */
+ | 'moved-ecosystem'
+/** Its executor hashes outside the plan, so it is always selected. */
+ | 'custom-hasher';
+export interface AffectedReason {
+    kind: AffectedReasonKind;
+    /** The changed file responsible, when one file is. */
+    file?: string;
+    /** The input pattern that matched, when the signal came from one. */
+    pattern?: string;
+    /** The package whose version moved. */
+    package?: string;
+    /** The package ecosystem, such as `npm`, that moved whole. */
+    ecosystem?: string;
+    /** The task whose outputs this task reads. */
+    producer?: string;
+}
+/**
+ * Why `--explain` cannot run here, naming only what is missing or in the way.
+ * It explains task selection, so it needs what task selection needs.
+ */
+export declare function explainUnavailable(missing: string[], conflicting?: string[]): string;
+/** What `--explain` reports, keyed by task id. */
+export interface AffectedExplanation {
+    /** The selection, and every reason each entry is in it. */
+    affected: Record<string, AffectedReason[]>;
+    /**
+     * Tasks the change reached that are not in the selection: those a run keeps,
+     * and every producer a reason names, followed transitively, so every chain
+     * can be traced within the same output.
+     */
+    upstream: Record<string, AffectedReason[]>;
+    /**
+     * The entries of `affected` and `upstream` the change reached directly, as
+     * selection decided it; every other entry was reached only through another.
+     */
+    touched: string[];
+    /** The requested targets, and how many of their tasks selection chose among. */
+    requested?: {
+        targets: string[];
+        total: number;
+    };
+    /** The packages each changed dependency file moved, when Nx could name them. */
+    moved?: Record<string, string[]>;
+}
+/** Stands in for a task's input reasons: entries of `inputs` to merge. */
+export interface InputsReason {
+    kind: 'inputs';
+    inputs: number[];
+}
+/**
+ * An explanation as selection builds it, before `hydrateExplanation`. A lib's
+ * matched files are one `inputs` entry however many tasks reach them, so this
+ * stays small across the daemon boundary where the expanded form would not.
+ */
+export interface InternedExplanation extends Omit<AffectedExplanation, 'affected' | 'upstream'> {
+    /** The input reasons each matching plan instruction produced, sorted per kind. */
+    inputs: AffectedReason[][];
+    affected: Record<string, (AffectedReason | InputsReason)[]>;
+    upstream: Record<string, (AffectedReason | InputsReason)[]>;
+}
+/** Expands each task's `inputs` stand-in into its reasons. */
+export declare function hydrateExplanation({ inputs, affected, upstream, ...rest }: InternedExplanation): AffectedExplanation;
+/**
+ * One line of `--explain` output, without the leading bullet. `many` is set
+ * when `file` names several files.
+ */
+export declare function formatAffectedReason(reason: AffectedReason, many?: boolean): string;
+/**
+ * Renders `--explain` output: one block per entity, its reasons beneath it.
+ *
+ * It follows the chain: what the change touched, what it reached through
+ * those, and last the selection itself, so the reader's own entries stay at
+ * the bottom however long the chain grows.
+ *
+ * An entity with no reason is still listed, with a line saying so, because a
+ * blank line is indistinguishable from a bug when you are troubleshooting.
+ */
+export declare function formatAffectedExplanation({ affected, upstream, touched: touchedNames, requested, moved, }: AffectedExplanation, heading: string, { verbose, styleTask, dim, bold, }?: {
+    verbose?: boolean;
+    /** Styles a listed task id; plain unless the printer passes a style. */
+    styleTask?: (id: string, requested: boolean) => string;
+    /** Styles the secondary part of a line, such as a matched pattern. */
+    dim?: (text: string) => string;
+    /** Styles the targets you asked for where a count names them. */
+    bold?: (text: string) => string;
+}): string;
+/** Whether `--explain` was asked for at all, in any of its forms. */
+export declare function isExplaining(value: string | boolean | undefined): boolean;