@nx/js 19.6.0-beta.1 → 19.6.0-beta.3

package/generators.json

@@ -42,10 +42,11 @@
       "alias": ["build"],
       "description": "setup-build generator"
     },
-    "sync": {
-      "factory": "./src/generators/sync/sync#syncGenerator",
-      "schema": "./src/generators/sync/schema.json",
+    "typescript-sync": {
+      "factory": "./src/generators/typescript-sync/typescript-sync",
+      "schema": "./src/generators/typescript-sync/schema.json",
       "description": "Synchronize TypeScript project references based on the project graph",
+      "alias": ["sync"],
       "hidden": true
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "19.6.0-beta.1",
+  "version": "19.6.0-beta.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": {
@@ -58,9 +58,9 @@
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
     "tslib": "^2.3.0",
-    "@nx/devkit": "19.6.0-beta.1",
-    "@nx/workspace": "19.6.0-beta.1",
-    "@nrwl/js": "19.6.0-beta.1"
+    "@nx/devkit": "19.6.0-beta.3",
+    "@nx/workspace": "19.6.0-beta.3",
+    "@nrwl/js": "19.6.0-beta.3"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

package/src/generators/release-version/release-version.js

@@ -290,7 +290,8 @@ To fix this you will either need to add a package.json file at that location, or
                             }
                         }
                         if (options.releaseGroup.projectsRelationship === 'independent') {
-                            specifier = options.releaseGroup.versionPlans.reduce((spec, plan) => {
+                            specifier = options.releaseGroup
+                                .resolvedVersionPlans.reduce((spec, plan) => {
                                 if (!spec) {
                                     return plan.projectVersionBumps[projectName];
                                 }
@@ -305,7 +306,7 @@ To fix this you will either need to add a package.json file at that location, or
                             }, null);
                         }
                         else {
-                            specifier = options.releaseGroup.versionPlans.reduce((spec, plan) => {
+                            specifier = options.releaseGroup.resolvedVersionPlans.reduce((spec, plan) => {
                                 if (!spec) {
                                     return plan.groupVersionBump;
                                 }
@@ -332,7 +333,7 @@ To fix this you will either need to add a package.json file at that location, or
                             logger.buffer(`📄 Resolved the specifier as "${specifier}" using version plans.`);
                         }
                         if (options.deleteVersionPlans) {
-                            options.releaseGroup.versionPlans.forEach((p) => {
+                            (options.releaseGroup.resolvedVersionPlans || []).forEach((p) => {
                                 deleteVersionPlanCallbacks.push(async (dryRun) => {
                                     if (!dryRun) {
                                         await (0, fs_extra_1.remove)(p.absolutePath);
@@ -386,7 +387,7 @@ To fix this you will either need to add a package.json file at that location, or
                 let isInCurrentBatch = options.projects.some((project) => project.name === dependentProject.source);
                 // For version-plans, we don't just need to consider the current batch of projects, but also the ones that are actually being updated as part of the plan file(s)
                 if (isInCurrentBatch && options.specifierSource === 'version-plans') {
-                    isInCurrentBatch = (options.releaseGroup.versionPlans || []).some((plan) => {
+                    isInCurrentBatch = (options.releaseGroup.resolvedVersionPlans || []).some((plan) => {
                         if ('projectVersionBumps' in plan) {
                             return plan.projectVersionBumps[dependentProject.source];
                         }

package/src/generators/typescript-sync/typescript-sync.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import type { SyncGeneratorResult } from 'nx/src/utils/sync-generators';
+export declare function syncGenerator(tree: Tree): Promise<SyncGeneratorResult>;
+export default syncGenerator;

package/src/generators/typescript-sync/typescript-sync.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncGenerator = syncGenerator;
+const devkit_1 = require("@nx/devkit");
+const posix_1 = require("node:path/posix");
+const plugin_1 = require("../../plugins/typescript/plugin");
+const COMMON_RUNTIME_TS_CONFIG_FILE_NAMES = [
+    'tsconfig.app.json',
+    'tsconfig.lib.json',
+    'tsconfig.build.json',
+    'tsconfig.cjs.json',
+    'tsconfig.esm.json',
+    'tsconfig.runtime.json',
+];
+async function syncGenerator(tree) {
+    // Ensure that the plugin has been wired up in nx.json
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const tscPluginConfig = nxJson.plugins.find((p) => {
+        if (typeof p === 'string') {
+            return p === plugin_1.PLUGIN_NAME;
+        }
+        return p.plugin === plugin_1.PLUGIN_NAME;
+    });
+    if (!tscPluginConfig) {
+        throw new Error(`The ${plugin_1.PLUGIN_NAME} plugin must be added to the "plugins" array in nx.json before syncing tsconfigs`);
+    }
+    // Root tsconfig containing project references for the whole workspace
+    const rootTsconfigPath = 'tsconfig.json';
+    if (!tree.exists(rootTsconfigPath)) {
+        throw new Error(`A "tsconfig.json" file must exist in the workspace root.`);
+    }
+    const rootTsconfig = (0, devkit_1.readJson)(tree, rootTsconfigPath);
+    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
+    const projectRoots = new Set();
+    const tsconfigProjectNodeValues = Object.values(projectGraph.nodes).filter((node) => {
+        projectRoots.add(node.data.root);
+        const projectTsconfigPath = (0, devkit_1.joinPathFragments)(node.data.root, 'tsconfig.json');
+        return tree.exists(projectTsconfigPath);
+    });
+    // Track if any changes were made to the tsconfig files. We check the changes
+    // made by this generator to know if the TS config is out of sync with the
+    // project graph. Therefore, we don't format the files if there were no changes
+    // to avoid potential format-only changes that can lead to false positives.
+    let hasChanges = false;
+    if (tsconfigProjectNodeValues.length > 0) {
+        const referencesSet = new Set();
+        for (const ref of rootTsconfig.references ?? []) {
+            // reference path is relative to the tsconfig file
+            const resolvedRefPath = getTsConfigPathFromReferencePath(tree, rootTsconfigPath, ref.path);
+            if (tree.exists(resolvedRefPath)) {
+                // we only keep the references that still exist
+                referencesSet.add(normalizeReferencePath(ref.path));
+            }
+            else {
+                hasChanges = true;
+            }
+        }
+        for (const node of tsconfigProjectNodeValues) {
+            const normalizedPath = normalizeReferencePath(node.data.root);
+            // Skip the root tsconfig itself
+            if (node.data.root !== '.' && !referencesSet.has(normalizedPath)) {
+                referencesSet.add(normalizedPath);
+                hasChanges = true;
+            }
+        }
+        if (hasChanges) {
+            rootTsconfig.references = Array.from(referencesSet).map((ref) => ({
+                path: `./${ref}`,
+            }));
+            (0, devkit_1.writeJson)(tree, rootTsconfigPath, rootTsconfig);
+        }
+    }
+    const runtimeTsConfigFileNames = nxJson.sync?.generatorOptions?.['@nx/js:typescript-sync']
+        ?.runtimeTsConfigFileNames ??
+        COMMON_RUNTIME_TS_CONFIG_FILE_NAMES;
+    const collectedDependencies = new Map();
+    for (const [name, data] of Object.entries(projectGraph.dependencies)) {
+        if (!projectGraph.nodes[name] ||
+            projectGraph.nodes[name].data.root === '.' ||
+            !data.length) {
+            continue;
+        }
+        // Get the source project nodes for the source and target
+        const sourceProjectNode = projectGraph.nodes[name];
+        // Find the relevant tsconfig file for the source project
+        const sourceProjectTsconfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, 'tsconfig.json');
+        if (!tree.exists(sourceProjectTsconfigPath)) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                devkit_1.logger.warn(`Skipping project "${name}" as there is no tsconfig.json file found in the project root "${sourceProjectNode.data.root}".`);
+            }
+            continue;
+        }
+        // Collect the dependencies of the source project
+        const dependencies = collectProjectDependencies(tree, name, projectGraph, collectedDependencies);
+        if (!dependencies.length) {
+            continue;
+        }
+        for (const runtimeTsConfigFileName of runtimeTsConfigFileNames) {
+            const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, runtimeTsConfigFileName);
+            if (!tree.exists(runtimeTsConfigPath)) {
+                continue;
+            }
+            // Update project references for the runtime tsconfig
+            hasChanges =
+                updateTsConfigReferences(tree, runtimeTsConfigPath, dependencies, sourceProjectNode.data.root, projectRoots, runtimeTsConfigFileName, runtimeTsConfigFileNames) || hasChanges;
+        }
+        // Update project references for the tsconfig.json file
+        hasChanges =
+            updateTsConfigReferences(tree, sourceProjectTsconfigPath, dependencies, sourceProjectNode.data.root, projectRoots) || hasChanges;
+    }
+    if (hasChanges) {
+        await (0, devkit_1.formatFiles)(tree);
+        return {
+            outOfSyncMessage: 'Based on the workspace project graph, some TypeScript configuration files are missing project references to the projects they depend on.',
+        };
+    }
+}
+exports.default = syncGenerator;
+function updateTsConfigReferences(tree, tsConfigPath, dependencies, projectRoot, projectRoots, runtimeTsConfigFileName, possibleRuntimeTsConfigFileNames) {
+    const tsConfig = (0, devkit_1.readJson)(tree, tsConfigPath);
+    // We have at least one dependency so we can safely set it to an empty array if not already set
+    const references = [];
+    const originalReferencesSet = new Set();
+    const newReferencesSet = new Set();
+    for (const ref of tsConfig.references ?? []) {
+        const normalizedPath = normalizeReferencePath(ref.path);
+        originalReferencesSet.add(normalizedPath);
+        // reference path is relative to the tsconfig file
+        const resolvedRefPath = getTsConfigPathFromReferencePath(tree, tsConfigPath, ref.path);
+        if (isInternalProjectReference(tree, resolvedRefPath, projectRoot, projectRoots)) {
+            // we keep all internal references
+            references.push(ref);
+            newReferencesSet.add(normalizedPath);
+        }
+    }
+    let hasChanges = false;
+    for (const dep of dependencies) {
+        // Ensure the project reference for the target is set
+        let referencePath = dep.data.root;
+        if (runtimeTsConfigFileName) {
+            const runtimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, runtimeTsConfigFileName);
+            if (tree.exists(runtimeTsConfigPath)) {
+                referencePath = runtimeTsConfigPath;
+            }
+            else {
+                // Check for other possible runtime tsconfig file names
+                // TODO(leo): should we check if there are more than one runtime tsconfig files and throw an error?
+                for (const possibleRuntimeTsConfigFileName of possibleRuntimeTsConfigFileNames ??
+                    []) {
+                    const possibleRuntimeTsConfigPath = (0, devkit_1.joinPathFragments)(dep.data.root, possibleRuntimeTsConfigFileName);
+                    if (tree.exists(possibleRuntimeTsConfigPath)) {
+                        referencePath = possibleRuntimeTsConfigPath;
+                        break;
+                    }
+                }
+            }
+        }
+        const relativePathToTargetRoot = (0, posix_1.relative)(projectRoot, referencePath);
+        if (!newReferencesSet.has(relativePathToTargetRoot)) {
+            newReferencesSet.add(relativePathToTargetRoot);
+            // Make sure we unshift rather than push so that dependencies are built in the right order by TypeScript when it is run directly from the root of the workspace
+            references.unshift({ path: relativePathToTargetRoot });
+        }
+        if (!originalReferencesSet.has(relativePathToTargetRoot)) {
+            hasChanges = true;
+        }
+    }
+    hasChanges ||= newReferencesSet.size !== originalReferencesSet.size;
+    if (hasChanges) {
+        tsConfig.references = references;
+        (0, devkit_1.writeJson)(tree, tsConfigPath, tsConfig);
+    }
+    return hasChanges;
+}
+// TODO(leo): follow up with the TypeScript team to confirm if we really need
+// to reference transitive dependencies.
+// Collect the dependencies of a project recursively sorted from root to leaf
+function collectProjectDependencies(tree, projectName, projectGraph, collectedDependencies) {
+    if (collectedDependencies.has(projectName)) {
+        // We've already collected the dependencies for this project
+        return collectedDependencies.get(projectName);
+    }
+    collectedDependencies.set(projectName, []);
+    for (const dep of projectGraph.dependencies[projectName]) {
+        const targetProjectNode = projectGraph.nodes[dep.target];
+        if (!targetProjectNode) {
+            // It's an npm dependency
+            continue;
+        }
+        // Add the target project node to the list of dependencies for the current project
+        if (!collectedDependencies
+            .get(projectName)
+            .some((d) => d.name === targetProjectNode.name)) {
+            collectedDependencies.get(projectName).push(targetProjectNode);
+        }
+        if (process.env.NX_DISABLE_TS_SYNC_TRANSITIVE_DEPENDENCIES === 'true') {
+            continue;
+        }
+        // Recursively get the dependencies of the target project
+        const transitiveDependencies = collectProjectDependencies(tree, dep.target, projectGraph, collectedDependencies);
+        for (const transitiveDep of transitiveDependencies) {
+            if (!collectedDependencies
+                .get(projectName)
+                .some((d) => d.name === transitiveDep.name)) {
+                collectedDependencies.get(projectName).push(transitiveDep);
+            }
+        }
+    }
+    return collectedDependencies.get(projectName);
+}
+// Normalize the paths to strip leading `./` and trailing `/tsconfig.json`
+function normalizeReferencePath(path) {
+    return (0, posix_1.normalize)(path)
+        .replace(/\/tsconfig.json$/, '')
+        .replace(/^\.\//, '');
+}
+function isInternalProjectReference(tree, refTsConfigPath, projectRoot, projectRoots) {
+    let currentPath = getTsConfigDirName(tree, refTsConfigPath);
+    if ((0, posix_1.relative)(projectRoot, currentPath).startsWith('..')) {
+        // it's outside of the project root, so it's an external project reference
+        return false;
+    }
+    while (currentPath !== projectRoot) {
+        if (projectRoots.has(currentPath)) {
+            // it's inside a nested project root, so it's and external project reference
+            return false;
+        }
+        currentPath = (0, posix_1.dirname)(currentPath);
+    }
+    // it's inside the project root, so it's an internal project reference
+    return true;
+}
+function getTsConfigDirName(tree, tsConfigPath) {
+    return tree.isFile(tsConfigPath)
+        ? (0, posix_1.dirname)(tsConfigPath)
+        : (0, posix_1.normalize)(tsConfigPath);
+}
+function getTsConfigPathFromReferencePath(tree, ownerTsConfigPath, referencePath) {
+    const resolvedRefPath = (0, devkit_1.joinPathFragments)((0, posix_1.dirname)(ownerTsConfigPath), referencePath);
+    return tree.isFile(resolvedRefPath)
+        ? resolvedRefPath
+        : (0, devkit_1.joinPathFragments)(resolvedRefPath, 'tsconfig.json');
+}

package/src/plugins/typescript/plugin.js

@@ -109,6 +109,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
                 cache: true,
                 inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
                 outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+                syncGenerators: ['@nx/js:typescript-sync'],
             };
         }
     }
@@ -123,6 +124,7 @@ function buildTscTargets(configFilePath, projectRoot, options, context) {
             cache: true,
             inputs: getInputs(namedInputs, configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
             outputs: getOutputs(configFilePath, tsConfig, internalProjectReferences, context.workspaceRoot, projectRoot),
+            syncGenerators: ['@nx/js:typescript-sync'],
         };
     }
     return { targets };

package/src/generators/sync/sync.d.ts

@@ -1,3 +0,0 @@
-import { Tree } from '@nx/devkit';
-import { SyncSchema } from './schema';
-export declare function syncGenerator(tree: Tree, options: SyncSchema): Promise<void>;

package/src/generators/sync/sync.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncGenerator = syncGenerator;
-const devkit_1 = require("@nx/devkit");
-const node_path_1 = require("node:path");
-const plugin_1 = require("../../plugins/typescript/plugin");
-async function syncGenerator(tree, options) {
-    // Ensure that the plugin has been wired up in nx.json
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    let tscPluginConfig = nxJson.plugins.find((p) => {
-        if (typeof p === 'string') {
-            return p === plugin_1.PLUGIN_NAME;
-        }
-        return p.plugin === plugin_1.PLUGIN_NAME;
-    });
-    if (!tscPluginConfig) {
-        throw new Error(`The ${plugin_1.PLUGIN_NAME} plugin must be added to the "plugins" array in nx.json before syncing tsconfigs`);
-    }
-    const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
-    const firstPartyDeps = Object.entries(projectGraph.dependencies).filter(([name, data]) => !name.startsWith('npm:') && data.length > 0);
-    // Root tsconfig containing project references for the whole workspace
-    const rootTsconfigPath = 'tsconfig.json';
-    const rootTsconfig = (0, devkit_1.readJson)(tree, rootTsconfigPath);
-    const tsconfigProjectNodeValues = Object.values(projectGraph.nodes).filter((node) => {
-        const projectTsconfigPath = (0, devkit_1.joinPathFragments)(node.data.root, 'tsconfig.json');
-        return tree.exists(projectTsconfigPath);
-    });
-    if (tsconfigProjectNodeValues.length > 0) {
-        // Sync the root tsconfig references from the project graph (do not destroy existing references)
-        rootTsconfig.references = rootTsconfig.references || [];
-        const referencesSet = new Set(rootTsconfig.references.map((ref) => normalizeReferencePath(ref.path)));
-        for (const node of tsconfigProjectNodeValues) {
-            const normalizedPath = normalizeReferencePath(node.data.root);
-            // Skip the root tsconfig itself
-            if (node.data.root !== '.' && !referencesSet.has(normalizedPath)) {
-                rootTsconfig.references.push({ path: `./${normalizedPath}` });
-            }
-        }
-        (0, devkit_1.writeJson)(tree, rootTsconfigPath, rootTsconfig);
-    }
-    for (const [name, data] of firstPartyDeps) {
-        // Get the source project nodes for the source and target
-        const sourceProjectNode = projectGraph.nodes[name];
-        // Find the relevant tsconfig files for the source project
-        const sourceProjectTsconfigPath = (0, devkit_1.joinPathFragments)(sourceProjectNode.data.root, 'tsconfig.json');
-        if (!tree.exists(sourceProjectTsconfigPath)) {
-            console.warn(`Skipping project "${name}" as there is no tsconfig.json file found in the project root "${sourceProjectNode.data.root}"`);
-            continue;
-        }
-        const sourceTsconfig = (0, devkit_1.readJson)(tree, sourceProjectTsconfigPath);
-        for (const dep of data) {
-            // Get the target project node
-            const targetProjectNode = projectGraph.nodes[dep.target];
-            if (!targetProjectNode) {
-                // It's an external dependency
-                continue;
-            }
-            // Set defaults only in the case where we have at least one dependency so that we don't patch files when not necessary
-            sourceTsconfig.references = sourceTsconfig.references || [];
-            // Ensure the project reference for the target is set
-            const relativePathToTargetRoot = (0, node_path_1.relative)(sourceProjectNode.data.root, targetProjectNode.data.root);
-            if (!sourceTsconfig.references.some((ref) => ref.path === relativePathToTargetRoot)) {
-                // Make sure we unshift rather than push so that dependencies are built in the right order by TypeScript when it is run directly from the root of the workspace
-                sourceTsconfig.references.unshift({ path: relativePathToTargetRoot });
-            }
-        }
-        // Update the source tsconfig files
-        (0, devkit_1.writeJson)(tree, sourceProjectTsconfigPath, sourceTsconfig);
-    }
-    await (0, devkit_1.formatFiles)(tree);
-}
-// Normalize the paths to strip leading `./` and trailing `/tsconfig.json`
-function normalizeReferencePath(path) {
-    return path.replace(/\/tsconfig.json$/, '').replace(/^\.\//, '');
-}