@nx/js 16.5.1 → 16.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.5.1",
+  "version": "16.5.3",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,9 +39,9 @@
     "@babel/preset-env": "^7.15.0",
     "@babel/preset-typescript": "^7.15.0",
     "@babel/runtime": "^7.14.8",
-    "@nrwl/js": "16.5.1",
-    "@nx/devkit": "16.5.1",
-    "@nx/workspace": "16.5.1",
+    "@nrwl/js": "16.5.3",
+    "@nx/devkit": "16.5.3",
+    "@nx/workspace": "16.5.3",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -69,5 +69,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "7b7f1e7f72a34cb31cff43ea0ebb80d0eab1ac79"
+  "gitHead": "e886dc76e203b05908b1a1b8872dee834cc4d2c8"
 }

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

@@ -32,6 +32,11 @@ function nodeExecutor(options, context) {
             throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
         }
         const buildTargetExecutor = (_c = project.data.targets[buildTarget.target]) === null || _c === void 0 ? void 0 : _c.executor;
+        if (buildTargetExecutor === 'nx:run-commands' ||
+            buildTargetExecutor === '@nrwl/workspace:run-commands') {
+            // Run commands does not emit build event, so we have to switch to run entire build through Nx CLI.
+            options.runBuildTargetDependencies = true;
+        }
         const buildOptions = Object.assign(Object.assign({}, (0, devkit_1.readTargetOptions)(buildTarget, context)), options.buildTargetOptions);
         if (options.waitUntilTargets && options.waitUntilTargets.length > 0) {
             const results = yield tslib_1.__await(runWaitUntilTargets(options, context));
@@ -44,8 +49,9 @@ function nodeExecutor(options, context) {
         // Re-map buildable workspace projects to their output directory.
         const mappings = calculateResolveMappings(context, options);
         const fileToRun = getFileToRun(context, project, buildOptions, buildTargetExecutor);
-        const tasks = [];
+        let additionalExitHandler = null;
         let currentTask = null;
+        const tasks = [];
         yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues((0, async_iterable_1.createAsyncIterable)(({ done, next, error }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
             var _e;
             const processQueue = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -58,59 +64,22 @@ function nodeExecutor(options, context) {
                 yield task.start();
             });
             const debouncedProcessQueue = debounce(processQueue, (_e = options.debounce) !== null && _e !== void 0 ? _e : 1000);
-            const addToQueue = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const addToQueue = (childProcess, buildResult) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const task = {
                     id: (0, crypto_1.randomUUID)(),
                     killed: false,
-                    childProcess: null,
+                    childProcess,
                     promise: null,
                     start: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                        if (options.runBuildTargetDependencies) {
-                            // If task dependencies are to be run, then we need to run through CLI since `runExecutor` doesn't support it.
-                            task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                                task.childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
-                                    'run',
-                                    `${context.projectName}:${buildTarget.target}${buildTarget.configuration
-                                        ? `:${buildTarget.configuration}`
-                                        : ''}`,
-                                ], {
-                                    cwd: context.root,
-                                    stdio: 'inherit',
-                                });
-                                task.childProcess.once('exit', (code) => {
-                                    if (code === 0)
-                                        resolve();
-                                    else
-                                        reject();
-                                });
-                            }));
-                        }
-                        else {
-                            const output = yield (0, devkit_1.runExecutor)(buildTarget, Object.assign(Object.assign({}, options.buildTargetOptions), { watch: false }), context);
-                            task.promise = new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                                var _g;
-                                let error = false;
-                                let event;
-                                do {
-                                    event = yield output.next();
-                                    if (((_g = event.value) === null || _g === void 0 ? void 0 : _g.success) === false) {
-                                        error = true;
-                                    }
-                                } while (!event.done);
-                                if (error)
-                                    reject();
-                                else
-                                    resolve();
-                            }));
-                        }
                         // Wait for build to finish.
-                        try {
-                            yield task.promise;
-                        }
-                        catch (_f) {
+                        const result = yield buildResult;
+                        if (!result.success) {
                             // If in watch-mode, don't throw or else the process exits.
                             if (options.watch) {
-                                devkit_1.logger.error(`Build failed, waiting for changes to restart...`);
+                                if (!task.killed) {
+                                    // Only log build error if task was not killed by a new change.
+                                    devkit_1.logger.error(`Build failed, waiting for changes to restart...`);
+                                }
                                 return;
                             }
                             else {
@@ -160,55 +129,88 @@ function nodeExecutor(options, context) {
                         try {
                             yield task.promise;
                         }
-                        catch (_h) {
+                        catch (_f) {
                             // Doesn't matter if task fails, we just need to wait until it finishes.
                         }
                     }),
                 };
                 tasks.push(task);
             });
-            if (options.watch) {
-                const stopWatch = yield client_1.daemonClient.registerFileWatcher({
+            if (options.runBuildTargetDependencies) {
+                // If a all dependencies need to be rebuild on changes, then register with watcher
+                // and run through CLI, otherwise only the current project will rebuild.
+                const runBuild = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    let childProcess = null;
+                    const whenReady = new Promise((resolve) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        childProcess = (0, child_process_1.fork)(require.resolve('nx'), [
+                            'run',
+                            `${context.projectName}:${buildTarget.target}${buildTarget.configuration ? `:${buildTarget.configuration}` : ''}`,
+                        ], {
+                            cwd: context.root,
+                            stdio: 'inherit',
+                        });
+                        childProcess.once('exit', (code) => {
+                            if (code === 0)
+                                resolve({ success: true });
+                            // If process is killed due to current task being killed, then resolve with success.
+                            else
+                                resolve({ success: !!(currentTask === null || currentTask === void 0 ? void 0 : currentTask.killed) });
+                        });
+                    }));
+                    yield addToQueue(childProcess, whenReady);
+                    yield debouncedProcessQueue();
+                });
+                additionalExitHandler = yield client_1.daemonClient.registerFileWatcher({
                     watchProjects: [context.projectName],
                     includeDependentProjects: true,
                 }, (err, data) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _j;
+                    var _g;
                     if (err === 'closed') {
                         devkit_1.logger.error(`Watch error: Daemon closed the connection`);
                         process.exit(1);
                     }
                     else if (err) {
-                        devkit_1.logger.error(`Watch error: ${(_j = err === null || err === void 0 ? void 0 : err.message) !== null && _j !== void 0 ? _j : 'Unknown'}`);
+                        devkit_1.logger.error(`Watch error: ${(_g = err === null || err === void 0 ? void 0 : err.message) !== null && _g !== void 0 ? _g : 'Unknown'}`);
                     }
                     else {
                         devkit_1.logger.info(`NX File change detected. Restarting...`);
-                        yield addToQueue();
-                        yield debouncedProcessQueue();
+                        yield runBuild();
                     }
                 }));
-                const stopAllTasks = (signal = 'SIGTERM') => {
-                    for (const task of tasks) {
-                        task.stop(signal);
+                yield runBuild(); // run first build
+            }
+            else {
+                // Otherwise, run the build executor, which will not run task dependencies.
+                // This is mostly fine for bundlers like webpack that should already watch for dependency libs.
+                // For tsc/swc or custom build commands, consider using `runBuildTargetDependencies` instead.
+                const output = yield (0, devkit_1.runExecutor)(buildTarget, Object.assign(Object.assign({}, options.buildTargetOptions), { watch: options.watch }), context);
+                while (true) {
+                    const event = yield output.next();
+                    yield addToQueue(null, Promise.resolve(event.value));
+                    yield debouncedProcessQueue();
+                    if (event.done || !options.watch) {
+                        break;
                     }
-                };
-                process.on('SIGTERM', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGTERM');
-                    process.exit(128 + 15);
-                }));
-                process.on('SIGINT', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGINT');
-                    process.exit(128 + 2);
-                }));
-                process.on('SIGHUP', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    stopWatch();
-                    stopAllTasks('SIGHUP');
-                    process.exit(128 + 1);
-                }));
+                }
             }
-            yield addToQueue();
-            yield processQueue();
+            const stopAllTasks = (signal = 'SIGTERM') => {
+                additionalExitHandler === null || additionalExitHandler === void 0 ? void 0 : additionalExitHandler();
+                for (const task of tasks) {
+                    task.stop(signal);
+                }
+            };
+            process.on('SIGTERM', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGTERM');
+                process.exit(128 + 15);
+            }));
+            process.on('SIGINT', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGINT');
+                process.exit(128 + 2);
+            }));
+            process.on('SIGHUP', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                stopAllTasks('SIGHUP');
+                process.exit(128 + 1);
+            }));
         })))));
     });
 }
@@ -251,6 +253,13 @@ function runWaitUntilTargets(options, context) {
     })));
 }
 function getFileToRun(context, project, buildOptions, buildTargetExecutor) {
+    // If using run-commands or another custom executor, then user should set
+    // outputFileName, but we can try the default value that we use.
+    if (!(buildOptions === null || buildOptions === void 0 ? void 0 : buildOptions.outputPath) && !(buildOptions === null || buildOptions === void 0 ? void 0 : buildOptions.outputFileName)) {
+        const fallbackFile = path.join('dist', project.data.root, 'main.js');
+        devkit_1.logger.warn(`Build option ${chalk.bold('outputFileName')} not set for ${chalk.bold(project.name)}. Using fallback value of ${chalk.bold(fallbackFile)}.`);
+        return (0, path_1.join)(context.root, fallbackFile);
+    }
     let outputFileName = buildOptions.outputFileName;
     if (!outputFileName) {
         const fileName = `${path.parse(buildOptions.main).name}.js`;

package/src/utils/find-npm-dependencies.d.ts

@@ -0,0 +1,7 @@
+import { type ProjectGraph, type ProjectGraphProjectNode, type ProjectFileMap } from '@nx/devkit';
+/**
+ * Finds all npm dependencies and their expected versions for a given project.
+ */
+export declare function findNpmDependencies(workspaceRoot: string, sourceProject: ProjectGraphProjectNode, projectGraph: ProjectGraph, projectFileMap: ProjectFileMap, buildTarget: string, options?: {
+    includeTransitiveDependencies?: boolean;
+}): Record<string, string>;

package/src/utils/find-npm-dependencies.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNpmDependencies = void 0;
+const path_1 = require("path");
+const file_utils_1 = require("nx/src/project-graph/file-utils");
+const task_hasher_1 = require("nx/src/hasher/task-hasher");
+const devkit_1 = require("@nx/devkit");
+const fileutils_1 = require("nx/src/utils/fileutils");
+const project_graph_1 = require("nx/src/config/project-graph");
+const ts_config_1 = require("./typescript/ts-config");
+/**
+ * Finds all npm dependencies and their expected versions for a given project.
+ */
+function findNpmDependencies(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, options = {}) {
+    let seen = null;
+    if (options.includeTransitiveDependencies) {
+        seen = new Set();
+    }
+    const results = {};
+    function collectAll(currentProject, collectedDeps) {
+        if (seen === null || seen === void 0 ? void 0 : seen.has(currentProject.name))
+            return;
+        collectDependenciesFromFileMap(workspaceRoot, currentProject, projectGraph, projectFileMap, buildTarget, collectedDeps);
+        collectHelperDependencies(workspaceRoot, currentProject, projectGraph, buildTarget, collectedDeps);
+        if (options.includeTransitiveDependencies) {
+            const projectDeps = projectGraph.dependencies[currentProject.name];
+            for (const dep of projectDeps) {
+                const projectDep = projectGraph.nodes[dep.target];
+                if (projectDep)
+                    collectAll(projectDep, collectedDeps);
+            }
+        }
+    }
+    collectAll(sourceProject, results);
+    return results;
+}
+exports.findNpmDependencies = findNpmDependencies;
+// Keep track of workspace libs we already read package.json for so we don't read from disk again.
+const seenWorkspaceDeps = {};
+function collectDependenciesFromFileMap(workspaceRoot, sourceProject, projectGraph, projectFileMap, buildTarget, npmDeps) {
+    const rawFiles = projectFileMap[sourceProject.name];
+    if (!rawFiles)
+        return;
+    // Cannot read inputs if the target does not exist on the project.
+    if (!sourceProject.data.targets[buildTarget])
+        return;
+    const inputs = (0, task_hasher_1.getTargetInputs)((0, file_utils_1.readNxJson)(), sourceProject, buildTarget).selfInputs;
+    const files = (0, task_hasher_1.filterUsingGlobPatterns)(sourceProject.data.root, projectFileMap[sourceProject.name] || [], inputs);
+    for (const fileData of files) {
+        if (!fileData.deps ||
+            fileData.file ===
+                (0, devkit_1.joinPathFragments)(sourceProject.data.root, 'package.json')) {
+            continue;
+        }
+        for (const dep of fileData.deps) {
+            const target = (0, project_graph_1.fileDataDepTarget)(dep);
+            // If the node is external, then read package info from `data`.
+            const externalDep = projectGraph.externalNodes[target];
+            if ((externalDep === null || externalDep === void 0 ? void 0 : externalDep.type) === 'npm') {
+                npmDeps[externalDep.data.packageName] = externalDep.data.version;
+                continue;
+            }
+            // If node is internal, then try reading package info from `package.json` (which must exist for this to work).
+            const workspaceDep = projectGraph.nodes[target];
+            if (!workspaceDep)
+                continue;
+            const cached = seenWorkspaceDeps[workspaceDep.name];
+            if (cached) {
+                npmDeps[cached.name] = cached.version;
+            }
+            else {
+                const packageJson = readPackageJson(workspaceDep, workspaceRoot);
+                if (packageJson) {
+                    // This is a workspace lib so we can't reliably read in a specific version since it depends on how the workspace is set up.
+                    // ASSUMPTION: Most users will use '*' for workspace lib versions. Otherwise, they can manually update it.
+                    npmDeps[packageJson.name] = '*';
+                    seenWorkspaceDeps[workspaceDep.name] = {
+                        name: packageJson.name,
+                        version: '*',
+                    };
+                }
+            }
+        }
+    }
+}
+function readPackageJson(project, workspaceRoot) {
+    const packageJsonPath = (0, path_1.join)(workspaceRoot, project.data.root, 'package.json');
+    if ((0, fileutils_1.fileExists)(packageJsonPath))
+        return (0, devkit_1.readJsonFile)(packageJsonPath);
+    return null;
+}
+function collectHelperDependencies(workspaceRoot, sourceProject, projectGraph, buildTarget, npmDeps) {
+    var _a, _b, _c, _d;
+    const target = sourceProject.data.targets[buildTarget];
+    if (!target)
+        return;
+    if (target.executor === '@nx/js:tsc' && ((_a = target.options) === null || _a === void 0 ? void 0 : _a.tsConfig)) {
+        const tsConfig = (0, ts_config_1.readTsConfig)((0, path_1.join)(workspaceRoot, target.options.tsConfig));
+        if (tsConfig === null || tsConfig === void 0 ? void 0 : tsConfig.options['importHelpers']) {
+            npmDeps['tslib'] = (_b = projectGraph.externalNodes['npm:tslib']) === null || _b === void 0 ? void 0 : _b.data.version;
+        }
+    }
+    if (target.executor === '@nx/js:swc') {
+        const swcConfigPath = target.options.swcrc
+            ? (0, path_1.join)(workspaceRoot, target.options.swcrc)
+            : (0, path_1.join)(workspaceRoot, sourceProject.data.root, '.swcrc');
+        const swcConfig = (0, fileutils_1.fileExists)(swcConfigPath)
+            ? (0, devkit_1.readJsonFile)(swcConfigPath)
+            : {};
+        if ((_c = swcConfig === null || swcConfig === void 0 ? void 0 : swcConfig.jsc) === null || _c === void 0 ? void 0 : _c.externalHelpers) {
+            npmDeps['@swc/helpers'] =
+                (_d = projectGraph.externalNodes['npm:@swc/helpers']) === null || _d === void 0 ? void 0 : _d.data.version;
+        }
+    }
+}