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

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

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

@@ -19,6 +19,7 @@ const resolve_local_package_dependencies_1 = require("./utils/resolve-local-pack
 const sort_projects_topologically_1 = require("./utils/sort-projects-topologically");
 const update_lock_file_1 = require("./utils/update-lock-file");
 async function releaseVersionGenerator(tree, options) {
+    let logger;
     try {
         const versionData = {};
         // If the user provided a specifier, validate that it is valid semver or a relative semver keyword
@@ -67,6 +68,8 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
             ? options.specifier
             : undefined;
         const deleteVersionPlanCallbacks = [];
+        // If the user has set the logUnchangedProjects option to false, we will not print any logs for projects that have no changes.
+        const logUnchangedProjects = options.logUnchangedProjects ?? true;
         for (const project of projects) {
             const projectName = project.name;
             const packageRoot = projectNameToPackageRootMap.get(projectName);
@@ -74,18 +77,15 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
                 throw new Error(`The project "${projectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
             }
             const packageJsonPath = (0, node_path_1.join)(packageRoot, 'package.json');
-            const color = getColor(projectName);
-            const log = (msg) => {
-                console.log(color.instance.bold(projectName) + ' ' + msg);
-            };
             if (!tree.exists(packageJsonPath)) {
                 throw new Error(`The project "${projectName}" does not have a package.json available at ${packageJsonPath}.
 
 To fix this you will either need to add a package.json file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
             }
-            devkit_1.output.logSingleLine(`Running release version for project: ${color.instance.bold(project.name)}`);
+            const color = getColor(projectName);
+            logger = new ProjectLogger(projectName, color);
             const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
-            log(`🔍 Reading data for package "${packageJson.name}" from ${packageJsonPath}`);
+            logger.buffer(`🔍 Reading data for package "${packageJson.name}" from ${packageJsonPath}`);
             const { name: packageName, version: currentVersionFromDisk } = packageJson;
             switch (options.currentVersionResolver) {
                 case 'registry': {
@@ -128,12 +128,12 @@ To fix this you will either need to add a package.json file at that location, or
                                 });
                             });
                             spinner.stop();
-                            log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
+                            logger.buffer(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
                         }
                         catch (e) {
                             spinner.stop();
                             if (options.fallbackCurrentVersionResolver === 'disk') {
-                                log(`📄 Unable to resolve the current version from the registry ${registry}. Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                logger.buffer(`📄 Unable to resolve the current version from the registry ${registry}. Falling back to the version on disk of ${currentVersionFromDisk}`);
                                 currentVersion = currentVersionFromDisk;
                                 currentVersionResolvedFromFallback = true;
                             }
@@ -144,10 +144,10 @@ To fix this you will either need to add a package.json file at that location, or
                     }
                     else {
                         if (currentVersionResolvedFromFallback) {
-                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                            logger.buffer(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
                         }
                         else {
-                            log(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
+                            logger.buffer(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
                         }
                     }
                     break;
@@ -157,7 +157,7 @@ To fix this you will either need to add a package.json file at that location, or
                     if (!currentVersion) {
                         throw new Error(`Unable to determine the current version for project "${project.name}" from ${packageJsonPath}`);
                     }
-                    log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
+                    logger.buffer(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
                     break;
                 case 'git-tag': {
                     if (!currentVersion ||
@@ -169,7 +169,7 @@ To fix this you will either need to add a package.json file at that location, or
                         });
                         if (!latestMatchingGitTag) {
                             if (options.fallbackCurrentVersionResolver === 'disk') {
-                                log(`📄 Unable to resolve the current version from git tag using pattern "${releaseTagPattern}". Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                logger.buffer(`📄 Unable to resolve the current version from git tag using pattern "${releaseTagPattern}". Falling back to the version on disk of ${currentVersionFromDisk}`);
                                 currentVersion = currentVersionFromDisk;
                                 currentVersionResolvedFromFallback = true;
                             }
@@ -179,15 +179,15 @@ To fix this you will either need to add a package.json file at that location, or
                         }
                         else {
                             currentVersion = latestMatchingGitTag.extractedVersion;
-                            log(`📄 Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
+                            logger.buffer(`📄 Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
                         }
                     }
                     else {
                         if (currentVersionResolvedFromFallback) {
-                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                            logger.buffer(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
                         }
                         else {
-                            log(
+                            logger.buffer(
                             // In this code path we know that latestMatchingGitTag is defined, because we are not relying on the fallbackCurrentVersionResolver, so we can safely use the non-null assertion operator
                             `📄 Using the current version ${currentVersion} already resolved from git tag "${latestMatchingGitTag.tag}".`);
                         }
@@ -198,7 +198,7 @@ To fix this you will either need to add a package.json file at that location, or
                     throw new Error(`Invalid value for options.currentVersionResolver: ${options.currentVersionResolver}`);
             }
             if (options.specifier) {
-                log(`📄 Using the provided version specifier "${options.specifier}".`);
+                logger.buffer(`📄 Using the provided version specifier "${options.specifier}".`);
                 // The user is forcibly overriding whatever specifierSource they had otherwise set by imperatively providing a specifier
                 options.specifierSource = 'prompt';
             }
@@ -240,10 +240,10 @@ To fix this you will either need to add a package.json file at that location, or
                             if (projectToDependencyBumps.has(projectName)) {
                                 // No applicable changes to the project directly by the user, but one or more dependencies have been bumped and updateDependents is enabled
                                 specifier = updateDependentsBump;
-                                log(`📄 Resolved the specifier as "${specifier}" because "release.version.generatorOptions.updateDependents" is enabled`);
+                                logger.buffer(`📄 Resolved the specifier as "${specifier}" because "release.version.generatorOptions.updateDependents" is enabled`);
                                 break;
                             }
-                            log(`🚫 No changes were detected using git history and the conventional commits standard.`);
+                            logger.buffer(`🚫 No changes were detected using git history and the conventional commits standard.`);
                             break;
                         }
                         // TODO: reevaluate this prerelease logic/workflow for independent projects
@@ -252,7 +252,7 @@ To fix this you will either need to add a package.json file at that location, or
                         // Users must manually graduate from a prerelease to a release by providing an explicit specifier.
                         if ((0, semver_2.prerelease)(currentVersion ?? '')) {
                             specifier = 'prerelease';
-                            log(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease.`);
+                            logger.buffer(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease.`);
                         }
                         else {
                             let extraText = '';
@@ -260,7 +260,7 @@ To fix this you will either need to add a package.json file at that location, or
                                 specifier = `pre${specifier}`;
                                 extraText = `, combined with your given preid "${options.preid}"`;
                             }
-                            log(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard${extraText}.`);
+                            logger.buffer(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard${extraText}.`);
                         }
                         break;
                     }
@@ -321,15 +321,15 @@ To fix this you will either need to add a package.json file at that location, or
                                 projectToDependencyBumps.has(projectName)) {
                                 // No applicable changes to the project directly by the user, but one or more dependencies have been bumped and updateDependents is enabled
                                 specifier = updateDependentsBump;
-                                log(`📄 Resolved the specifier as "${specifier}" because "release.version.generatorOptions.updateDependents" is enabled`);
+                                logger.buffer(`📄 Resolved the specifier as "${specifier}" because "release.version.generatorOptions.updateDependents" is enabled`);
                             }
                             else {
                                 specifier = null;
-                                log(`🚫 No changes were detected within version plans.`);
+                                logger.buffer(`🚫 No changes were detected within version plans.`);
                             }
                         }
                         else {
-                            log(`📄 Resolved the specifier as "${specifier}" using version plans.`);
+                            logger.buffer(`📄 Resolved the specifier as "${specifier}" using version plans.`);
                         }
                         if (options.deleteVersionPlans) {
                             options.releaseGroup.versionPlans.forEach((p) => {
@@ -420,7 +420,7 @@ To fix this you will either need to add a package.json file at that location, or
                         .map((dependentProject) => `${indent}- ${dependentProject.source}`)
                         .join('\n')}`;
                     logMsg += `\n${indent}=> You can adjust this behavior by setting \`version.generatorOptions.updateDependents\` to "auto"`;
-                    log(logMsg);
+                    logger.buffer(logMsg);
                 }
             }
             if (!currentVersion) {
@@ -434,7 +434,11 @@ To fix this you will either need to add a package.json file at that location, or
                     : dependentProjectsInCurrentBatch,
             };
             if (!specifier) {
-                log(`🚫 Skipping versioning "${packageJson.name}" as no changes were detected.`);
+                logger.buffer(`🚫 Skipping versioning "${packageJson.name}" as no changes were detected.`);
+                // Print the buffered logs for this unchanged project, as long as the user has not explicitly disabled this behavior
+                if (logUnchangedProjects) {
+                    logger.flush();
+                }
                 continue;
             }
             const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
@@ -443,7 +447,7 @@ To fix this you will either need to add a package.json file at that location, or
                 ...packageJson,
                 version: newVersion,
             });
-            log(`✍️  New version ${newVersion} written to ${packageJsonPath}`);
+            logger.buffer(`✍️  New version ${newVersion} written to ${packageJsonPath}`);
             if (allDependentProjects.length > 0) {
                 const totalProjectsToUpdate = updateDependents === 'auto'
                     ? allDependentProjects.length +
@@ -452,7 +456,7 @@ To fix this you will either need to add a package.json file at that location, or
                         circularDependencies.size / 2
                     : dependentProjectsInCurrentBatch.length;
                 if (totalProjectsToUpdate > 0) {
-                    log(`✍️  Applying new version ${newVersion} to ${totalProjectsToUpdate} ${totalProjectsToUpdate > 1
+                    logger.buffer(`✍️  Applying new version ${newVersion} to ${totalProjectsToUpdate} ${totalProjectsToUpdate > 1
                         ? 'packages which depend'
                         : 'package which depends'} on ${project.name}`);
                 }
@@ -555,6 +559,8 @@ To fix this you will either need to add a package.json file at that location, or
                         : updateDependentsBump,
                 });
             }
+            // Print the logs that have been buffered for this project
+            logger.flush();
         }
         /**
          * Ensure that formatting is applied so that version bump diffs are as minimal as possible
@@ -577,6 +583,8 @@ To fix this you will either need to add a package.json file at that location, or
         };
     }
     catch (e) {
+        // Flush any pending logs before printing the error to make troubleshooting easier
+        logger?.flush();
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
             devkit_1.output.error({
                 title: e.message,
@@ -630,3 +638,19 @@ function getColor(projectName) {
     const colorIndex = code % colors.length;
     return colors[colorIndex];
 }
+class ProjectLogger {
+    constructor(projectName, color) {
+        this.projectName = projectName;
+        this.color = color;
+        this.logs = [];
+    }
+    buffer(msg) {
+        this.logs.push(msg);
+    }
+    flush() {
+        devkit_1.output.logSingleLine(`Running release version for project: ${this.color.instance.bold(this.projectName)}`);
+        this.logs.forEach((msg) => {
+            console.log(this.color.instance.bold(this.projectName) + ' ' + msg);
+        });
+    }
+}

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(/^\.\//, '');
-}