nx 21.2.0-beta.1 → 21.2.0-beta.3

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

@@ -9,6 +9,7 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
 const logger_1 = require("../../../utils/logger");
+const typescript_1 = require("./typescript");
 const swcNodeInstalled = packageIsInstalled('@swc-node/register');
 const tsNodeInstalled = packageIsInstalled('ts-node/register');
 let ts;
@@ -53,10 +54,10 @@ function registerTsProject(path, configFilename) {
         return () => { };
     }
     const tsConfigPath = configFilename ? (0, path_1.join)(path, configFilename) : path;
-    const compilerOptions = readCompilerOptions(tsConfigPath);
+    const { compilerOptions, tsConfigRaw } = readCompilerOptions(tsConfigPath);
     const cleanupFunctions = [
         registerTsConfigPaths(tsConfigPath),
-        registerTranspiler(compilerOptions),
+        registerTranspiler(compilerOptions, tsConfigRaw),
     ];
     // Add ESM support for `.ts` files.
     // NOTE: There is no cleanup function for this, as it's not possible to unregister the loader.
@@ -90,12 +91,16 @@ function getSwcTranspiler(compilerOptions) {
     const cleanupFn = register(compilerOptions);
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
-function getTsNodeTranspiler(compilerOptions) {
+function getTsNodeTranspiler(compilerOptions, tsNodeOptions) {
     const { register } = require('ts-node');
     // ts-node doesn't provide a cleanup method
     const service = register({
+        ...tsNodeOptions,
         transpileOnly: true,
-        compilerOptions: getTsNodeCompilerOptions(compilerOptions),
+        compilerOptions: getTsNodeCompilerOptions({
+            ...tsNodeOptions?.compilerOptions,
+            ...compilerOptions,
+        }),
         // we already read and provide the compiler options, so prevent ts-node from reading them again
         skipProject: true,
     });
@@ -165,21 +170,30 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
     compilerOptions.target = ts.ScriptTarget.ES2021;
     compilerOptions.inlineSourceMap = true;
     compilerOptions.skipLibCheck = true;
+    let _getTranspiler;
+    let registrationKey = JSON.stringify(compilerOptions);
+    let tsNodeOptions;
+    if (swcNodeInstalled && !preferTsNode) {
+        _getTranspiler = getSwcTranspiler;
+    }
+    else if (tsNodeInstalled) {
+        // We can fall back on ts-node if it's available
+        _getTranspiler = getTsNodeTranspiler;
+        tsNodeOptions = filterRecognizedTsConfigTsNodeOptions(tsConfigRaw?.['ts-node']).recognized;
+        // include ts-node options in the registration key
+        registrationKey += JSON.stringify(tsNodeOptions);
+    }
+    else {
+        _getTranspiler = undefined;
+    }
     // Just return if transpiler was already registered before.
-    const registrationKey = JSON.stringify(compilerOptions);
     const registrationEntry = registered.get(registrationKey);
     if (registered.has(registrationKey)) {
         registrationEntry.refCount++;
         return registrationEntry.cleanup;
     }
-    const _getTranspiler = swcNodeInstalled && !preferTsNode
-        ? getSwcTranspiler
-        : tsNodeInstalled
-            ? // We can fall back on ts-node if it's available
-                getTsNodeTranspiler
-            : undefined;
     if (_getTranspiler) {
-        const transpilerCleanup = _getTranspiler(compilerOptions);
+        const transpilerCleanup = _getTranspiler(compilerOptions, tsNodeOptions);
         const currRegistrationEntry = {
             refCount: 1,
             cleanup: () => {
@@ -204,9 +218,9 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
  *
  * @returns cleanup method
  */
-function registerTranspiler(compilerOptions) {
+function registerTranspiler(compilerOptions, tsConfigRaw) {
     // Function to register transpiler that returns cleanup function
-    const transpiler = getTranspiler(compilerOptions);
+    const transpiler = getTranspiler(compilerOptions, tsConfigRaw);
     if (!transpiler) {
         warnNoTranspiler();
         return () => { };
@@ -245,7 +259,9 @@ function registerTsConfigPaths(tsConfigPath) {
 function readCompilerOptions(tsConfigPath) {
     const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
     if (swcNodeInstalled && !preferTsNode) {
-        return readCompilerOptionsWithSwc(tsConfigPath);
+        return {
+            compilerOptions: readCompilerOptionsWithSwc(tsConfigPath),
+        };
     }
     else {
         return readCompilerOptionsWithTypescript(tsConfigPath);
@@ -261,16 +277,14 @@ function readCompilerOptionsWithSwc(tsConfigPath) {
     return compilerOptions;
 }
 function readCompilerOptionsWithTypescript(tsConfigPath) {
-    if (!ts) {
-        ts = require('typescript');
-    }
-    const { readConfigFile, parseJsonConfigFileContent, sys } = ts;
-    const jsonContent = readConfigFile(tsConfigPath, sys.readFile);
-    const { options } = parseJsonConfigFileContent(jsonContent.config, sys, (0, path_1.dirname)(tsConfigPath));
+    const { options, raw } = (0, typescript_1.readTsConfigWithoutFiles)(tsConfigPath);
     // This property is returned in compiler options for some reason, but not part of the typings.
     // ts-node fails on unknown props, so we have to remove it.
     delete options.configFilePath;
-    return options;
+    return {
+        compilerOptions: options,
+        tsConfigRaw: raw,
+    };
 }
 function loadTsConfigPaths() {
     try {

package/src/plugins/js/utils/typescript.d.ts

@@ -1,6 +1,7 @@
 import type * as ts from 'typescript';
 import type { Node, SyntaxKind } from 'typescript';
-export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+export declare function readTsConfig(tsConfigPath: string, sys?: ts.System): ts.ParsedCommandLine;
+export declare function readTsConfigWithoutFiles(tsConfigPath: string): ts.ParsedCommandLine;
 export declare function readTsConfigOptions(tsConfigPath: string): ts.CompilerOptions;
 /**
  * Find a module based on its import

package/src/plugins/js/utils/typescript.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readTsConfig = readTsConfig;
+exports.readTsConfigWithoutFiles = readTsConfigWithoutFiles;
 exports.readTsConfigOptions = readTsConfigOptions;
 exports.resolveModuleByImport = resolveModuleByImport;
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
@@ -11,25 +12,29 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 const normalizedAppRoot = workspace_root_1.workspaceRoot.replace(/\\/g, '/');
 let tsModule;
-function readTsConfig(tsConfigPath) {
+function readTsConfig(tsConfigPath, sys) {
     if (!tsModule) {
         tsModule = require('typescript');
     }
-    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
-    return tsModule.parseJsonConfigFileContent(readResult.config, tsModule.sys, (0, path_1.dirname)(tsConfigPath));
+    sys ??= tsModule.sys;
+    const readResult = tsModule.readConfigFile(tsConfigPath, sys.readFile);
+    return tsModule.parseJsonConfigFileContent(readResult.config, sys, (0, path_1.dirname)(tsConfigPath));
 }
-function readTsConfigOptions(tsConfigPath) {
+function readTsConfigWithoutFiles(tsConfigPath) {
     if (!tsModule) {
         tsModule = require('typescript');
     }
-    const readResult = tsModule.readConfigFile(tsConfigPath, tsModule.sys.readFile);
     // We only care about options, so we don't need to scan source files, and thus
     // `readDirectory` is stubbed for performance.
-    const host = {
+    const sys = {
         ...tsModule.sys,
         readDirectory: () => [],
     };
-    return tsModule.parseJsonConfigFileContent(readResult.config, host, (0, path_1.dirname)(tsConfigPath)).options;
+    return readTsConfig(tsConfigPath, sys);
+}
+function readTsConfigOptions(tsConfigPath) {
+    const { options } = readTsConfigWithoutFiles(tsConfigPath);
+    return options;
 }
 let compilerHost;
 /**

package/src/project-graph/plugins/transpiler.js

@@ -6,9 +6,9 @@ exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
 exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
 const node_fs_1 = require("node:fs");
 const posix_1 = require("node:path/posix");
-const workspace_root_1 = require("../../utils/workspace-root");
 const register_1 = require("../../plugins/js/utils/register");
 const typescript_1 = require("../../plugins/js/utils/typescript");
+const workspace_root_1 = require("../../utils/workspace-root");
 exports.unregisterPluginTSTranspiler = null;
 /**
  * Register swc-node or ts-node if they are not currently registered
@@ -23,16 +23,16 @@ function registerPluginTSTranspiler() {
     if (!tsConfigName) {
         return;
     }
-    const tsConfigOptions = tsConfigName
-        ? (0, typescript_1.readTsConfigOptions)(tsConfigName)
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfigWithoutFiles)(tsConfigName)
         : {};
     const cleanupFns = [
         (0, register_1.registerTsConfigPaths)(tsConfigName),
         (0, register_1.registerTranspiler)({
             experimentalDecorators: true,
             emitDecoratorMetadata: true,
-            ...tsConfigOptions,
-        }),
+            ...tsConfig.options,
+        }, tsConfig.raw),
     ];
     exports.unregisterPluginTSTranspiler = () => {
         cleanupFns.forEach((fn) => fn?.());

package/src/tasks-runner/run-command.js

@@ -142,7 +142,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
                             : chunk.toString());
                     }
                     else {
-                        (0, native_1.logInfo)(Buffer.isBuffer(chunk)
+                        (0, native_1.logDebug)(Buffer.isBuffer(chunk)
                             ? chunk.toString(encoding)
                             : chunk.toString());
                     }
@@ -772,6 +772,17 @@ function getRunner(nxArgs, nxJson) {
 }
 const defaultTasksRunnerPath = require.resolve('./default-tasks-runner');
 function getTasksRunnerPath(runner, nxJson) {
+    // If running inside of Codex, there will be no internet access, so we cannot use the cloud runner, regardless of other config.
+    // We can infer this scenario by checking for certain environment variables defined in their base image: https://github.com/openai/codex-universal
+    if (process.env.CODEX_ENV_NODE_VERSION) {
+        output_1.output.warn({
+            title: 'Codex environment detected, using default tasks runner',
+            bodyLines: [
+                'Codex does not have internet access when it runs tasks, so Nx will use the default tasks runner and only leverage local caching.',
+            ],
+        });
+        return defaultTasksRunnerPath;
+    }
     const isCloudRunner = 
     // No tasksRunnerOptions for given --runner
     nxJson.nxCloudAccessToken ||

package/src/tasks-runner/running-tasks/noop-child-process.d.ts

@@ -11,5 +11,6 @@ export declare class NoopChildProcess implements RunningTask {
         terminalOutput: string;
     }>;
     kill(): void;
-    onExit(cb: (code: number) => void): void;
+    onExit(cb: (code: number, terminalOutput: string) => void): void;
+    onOutput(cb: (terminalOutput: string) => void): void;
 }

package/src/tasks-runner/running-tasks/noop-child-process.js

@@ -13,7 +13,10 @@ class NoopChildProcess {
         return;
     }
     onExit(cb) {
-        cb(this.results.code);
+        cb(this.results.code, this.results.terminalOutput);
+    }
+    onOutput(cb) {
+        cb(this.results.terminalOutput);
     }
 }
 exports.NoopChildProcess = NoopChildProcess;

package/src/utils/nx-console-prompt.d.ts

@@ -0,0 +1 @@
+export declare function ensureNxConsoleInstalled(): Promise<void>;

package/src/utils/nx-console-prompt.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNxConsoleInstalled = ensureNxConsoleInstalled;
+const enquirer_1 = require("enquirer");
+const os_1 = require("os");
+const output_1 = require("./output");
+const native_1 = require("../native");
+async function ensureNxConsoleInstalled() {
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    let setting = preferences.getAutoInstallPreference();
+    const canInstallConsole = (0, native_1.canInstallNxConsole)();
+    // Noop
+    if (!canInstallConsole) {
+        return;
+    }
+    if (typeof setting !== 'boolean') {
+        setting = await promptForNxConsoleInstallation();
+        preferences.setAutoInstallPreference(setting);
+    }
+    if (setting) {
+        (0, native_1.installNxConsole)();
+    }
+}
+/**
+ * Prompts the user whether they want to automatically install the Nx Console extension
+ * and persists their preference using the NxConsolePreferences struct
+ */
+async function promptForNxConsoleInstallation() {
+    try {
+        output_1.output.log({
+            title: "Enhance your developer experience with Nx Console, Nx's official editor extension",
+            bodyLines: [
+                '- Enable your AI assistant to do more by understanding your workspace',
+                '- Add IntelliSense for Nx configuration files',
+                '- Explore your workspace visually',
+                '- Generate code and execute tasks interactively',
+            ],
+        });
+        const { shouldInstallNxConsole } = await (0, enquirer_1.prompt)({
+            type: 'confirm',
+            name: 'shouldInstallNxConsole',
+            message: 'Install Nx Console? (you can uninstall anytime)',
+            initial: true,
+        });
+        return shouldInstallNxConsole;
+    }
+    catch (error) {
+        return false;
+    }
+}