@nx/js 16.6.0-beta.0 → 16.6.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.6.0-beta.0",
+  "version": "16.6.0-beta.2",
   "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.6.0-beta.0",
-    "@nx/devkit": "16.6.0-beta.0",
-    "@nx/workspace": "16.6.0-beta.0",
+    "@nrwl/js": "16.6.0-beta.2",
+    "@nx/devkit": "16.6.0-beta.2",
+    "@nx/workspace": "16.6.0-beta.2",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
@@ -55,6 +55,8 @@
     "minimatch": "3.0.5",
     "semver": "7.5.3",
     "source-map-support": "0.5.19",
+    "ts-node": "10.9.1",
+    "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
@@ -69,5 +71,5 @@
     "access": "public"
   },
   "types": "./src/index.d.ts",
-  "gitHead": "5a7ffb93c9e84bffbf52f6ae9c6c1e3b8edb9d35"
+  "gitHead": "c3d31711b71d648cedeff688fce9334d393b586b"
 }

package/src/executors/swc/schema.json

@@ -69,13 +69,15 @@
     "updateBuildableProjectDepsInPackageJson": {
       "type": "boolean",
       "description": "Whether to update the buildable project dependencies in the build output package.json.",
-      "default": false
+      "default": false,
+      "x-deprecated": "Configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks). It will be removed in v17."
     },
     "buildableProjectDepsInPackageJsonType": {
       "type": "string",
       "description": "When `updateBuildableProjectDepsInPackageJson` is `true`, this adds dependencies to either `peerDependencies` or `dependencies`.",
       "enum": ["dependencies", "peerDependencies"],
-      "default": "peerDependencies"
+      "default": "peerDependencies",
+      "x-deprecated": "Configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks). It will be removed in v17."
     },
     "external": {
       "description": "A list projects to be treated as external. This feature is experimental",

package/src/executors/tsc/schema.json

@@ -57,13 +57,15 @@
     "updateBuildableProjectDepsInPackageJson": {
       "type": "boolean",
       "description": "Whether to update the buildable project dependencies in the build output package.json.",
-      "default": false
+      "default": false,
+      "x-deprecated": "Configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks). It will be removed in v17."
     },
     "buildableProjectDepsInPackageJsonType": {
       "type": "string",
       "description": "When `updateBuildableProjectDepsInPackageJson` is `true`, this adds dependencies to either `peerDependencies` or `dependencies`.",
       "enum": ["dependencies", "peerDependencies"],
-      "default": "peerDependencies"
+      "default": "peerDependencies",
+      "x-deprecated": "Configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks). It will be removed in v17."
     },
     "external": {
       "description": "A list projects to be treated as external. This feature is experimental",

package/src/executors/tsc/tsc.batch-impl.js

@@ -43,20 +43,21 @@ function tscBatchExecutor(taskGraph, inputs, overrides, context) {
                 }
             },
         };
+        const processTaskPostCompilation = (tsConfig) => {
+            if (tsConfigTaskInfoMap[tsConfig]) {
+                const taskInfo = tsConfigTaskInfoMap[tsConfig];
+                taskInfo.assetsHandler.processAllAssetsOnceSync();
+                (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
+                taskInfo.endTime = Date.now();
+            }
+        };
         const typescriptCompilation = (0, lib_1.compileTypescriptSolution)(tsCompilationContext, shouldWatch, logger, {
             beforeProjectCompilationCallback: (tsConfig) => {
                 if (tsConfigTaskInfoMap[tsConfig]) {
                     tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
                 }
             },
-            afterProjectCompilationCallback: (tsConfig) => {
-                if (tsConfigTaskInfoMap[tsConfig]) {
-                    const taskInfo = tsConfigTaskInfoMap[tsConfig];
-                    taskInfo.assetsHandler.processAllAssetsOnceSync();
-                    (0, update_package_json_1.updatePackageJson)(taskInfo.options, taskInfo.context, taskInfo.projectGraphNode, taskInfo.buildableProjectNodeDependencies);
-                    taskInfo.endTime = Date.now();
-                }
-            },
+            afterProjectCompilationCallback: processTaskPostCompilation,
         });
         if (shouldWatch) {
             const taskInfos = Object.values(tsConfigTaskInfoMap);
@@ -79,21 +80,54 @@ function tscBatchExecutor(taskGraph, inputs, overrides, context) {
                 return { value: undefined, done: true };
             }))))));
         }
+        const toBatchExecutorTaskResult = (tsConfig, success) => ({
+            task: tsConfigTaskInfoMap[tsConfig].task,
+            result: {
+                success: success,
+                terminalOutput: tsConfigTaskInfoMap[tsConfig].terminalOutput,
+                startTime: tsConfigTaskInfoMap[tsConfig].startTime,
+                endTime: tsConfigTaskInfoMap[tsConfig].endTime,
+            },
+        });
+        let isCompilationDone = false;
+        const taskTsConfigsToReport = new Set(Object.keys(taskGraph.tasks).map((t) => taskInMemoryTsConfigMap[t].path));
+        let tasksToReportIterator;
+        const processSkippedTasks = () => {
+            const { value: tsConfig, done } = tasksToReportIterator.next();
+            if (done) {
+                return { value: undefined, done: true };
+            }
+            tsConfigTaskInfoMap[tsConfig].startTime = Date.now();
+            processTaskPostCompilation(tsConfig);
+            return { value: toBatchExecutorTaskResult(tsConfig, true), done: false };
+        };
         return yield tslib_1.__await(yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(mapAsyncIterable(typescriptCompilation, (iterator) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (isCompilationDone) {
+                return processSkippedTasks();
+            }
             const { value, done } = yield iterator.next();
             if (done) {
-                return { value, done: true };
+                if (taskTsConfigsToReport.size > 0) {
+                    /**
+                     * TS compilation is done but we still have tasks to report. This can
+                     * happen if, for example, a project is identified as affected, but
+                     * no file in the TS project is actually changed or if running a
+                     * task with `--skip-nx-cache` and the outputs are already there. There
+                     * can still be changes to assets or other files we need to process.
+                     *
+                     * Switch to handle the iterator for the tasks we still need to report.
+                     */
+                    isCompilationDone = true;
+                    tasksToReportIterator = taskTsConfigsToReport.values();
+                    return processSkippedTasks();
+                }
+                return { value: undefined, done: true };
             }
-            const taskResult = {
-                task: tsConfigTaskInfoMap[value.tsConfig].task,
-                result: {
-                    success: value.success,
-                    terminalOutput: tsConfigTaskInfoMap[value.tsConfig].terminalOutput,
-                    startTime: tsConfigTaskInfoMap[value.tsConfig].startTime,
-                    endTime: tsConfigTaskInfoMap[value.tsConfig].endTime,
-                },
+            taskTsConfigsToReport.delete(value.tsConfig);
+            return {
+                value: toBatchExecutorTaskResult(value.tsConfig, value.success),
+                done: false,
             };
-            return { value: taskResult, done: false };
         }))))));
     });
 }

package/src/generators/library/library.js

@@ -238,8 +238,8 @@ function createFiles(tree, options, filesDir) {
 }
 function addJest(tree, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { jestProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
-        return yield jestProjectGenerator(tree, Object.assign(Object.assign({}, options), { project: options.name, setupFile: 'none', supportTsx: false, skipSerializers: true, testEnvironment: options.testEnvironment, skipFormat: true, compiler: options.bundler === 'swc' || options.bundler === 'tsc'
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
+        return yield configurationGenerator(tree, Object.assign(Object.assign({}, options), { project: options.name, setupFile: 'none', supportTsx: false, skipSerializers: true, testEnvironment: options.testEnvironment, skipFormat: true, compiler: options.bundler === 'swc' || options.bundler === 'tsc'
                 ? options.bundler
                 : options.bundler === 'rollup'
                     ? 'swc'

package/src/migrations/update-16-6-0/explicitly-set-projects-to-update-buildable-deps.js

@@ -9,26 +9,29 @@ const executors = new Set([
     '@nrwl/js:tsc',
 ]);
 function default_1(tree) {
+    var _a;
+    var _b;
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const projects = (0, devkit_1.getProjects)(tree);
-        for (const [projectName, project] of projects) {
-            if (project.projectType !== 'library') {
+        // use project graph to get the expanded target configurations
+        const projectGraph = yield (0, devkit_1.createProjectGraphAsync)();
+        for (const [projectName, { data: projectData }] of Object.entries(projectGraph.nodes)) {
+            if (projectData.projectType !== 'library') {
                 continue;
             }
-            let updated = false;
-            for (const [, target] of Object.entries(project.targets || {})) {
+            for (const [targetName, target] of Object.entries(projectData.targets || {})) {
                 if (!executors.has(target.executor)) {
                     continue;
                 }
-                if (target.options &&
+                if (!target.options ||
                     target.options.updateBuildableProjectDepsInPackageJson === undefined) {
-                    target.options.updateBuildableProjectDepsInPackageJson = true;
-                    updated = true;
+                    // read the project configuration to write the explicit project configuration
+                    // and avoid writing the expanded target configuration
+                    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+                    (_a = (_b = project.targets[targetName]).options) !== null && _a !== void 0 ? _a : (_b.options = {});
+                    project.targets[targetName].options.updateBuildableProjectDepsInPackageJson = true;
+                    (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
                 }
             }
-            if (updated) {
-                (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
-            }
         }
         yield (0, devkit_1.formatFiles)(tree);
     });

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;
+        }
+    }
+}

package/src/utils/schema.d.ts

@@ -42,7 +42,17 @@ export interface ExecutorOptions {
   watch: boolean;
   clean?: boolean;
   transformers: TransformerEntry[];
+  /**
+   * @deprecated Configure the project to use the `@nx/dependency-checks` ESLint
+   * rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks).
+   * It will be removed in v17.
+   */
   updateBuildableProjectDepsInPackageJson?: boolean;
+  /**
+   * @deprecated Configure the project to use the `@nx/dependency-checks` ESLint
+   * rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks).
+   * It will be removed in v17.
+   */
   buildableProjectDepsInPackageJsonType?: 'dependencies' | 'peerDependencies';
   external?: 'all' | 'none' | string[];
   externalBuildTargets?: string[];

package/src/utils/typescript/tsnode-register.d.ts

@@ -0,0 +1 @@
+export declare function tsNodeRegister(file: string, tsConfig?: string): void;

package/src/utils/typescript/tsnode-register.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsNodeRegister = void 0;
+function tsNodeRegister(file, tsConfig) {
+    if (!(file === null || file === void 0 ? void 0 : file.endsWith('.ts')))
+        return;
+    // Register TS compiler lazily
+    require('ts-node').register({
+        project: tsConfig,
+        compilerOptions: {
+            module: 'CommonJS',
+            types: ['node'],
+        },
+    });
+    if (!tsConfig)
+        return;
+    // Register paths in tsConfig
+    const tsconfigPaths = require('tsconfig-paths');
+    const { absoluteBaseUrl: baseUrl, paths } = tsconfigPaths.loadConfig(tsConfig);
+    if (baseUrl && paths) {
+        tsconfigPaths.register({ baseUrl, paths });
+    }
+}
+exports.tsNodeRegister = tsNodeRegister;