nx 20.8.4 → 22.7.7

package/src/command-line/release/version/test-utils.js

@@ -1,416 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExampleNonSemverVersionActions = exports.ExampleRustVersionActions = void 0;
-exports.createNxReleaseConfigAndPopulateWorkspace = createNxReleaseConfigAndPopulateWorkspace;
-exports.parseGraphDefinition = parseGraphDefinition;
-exports.mockResolveVersionActionsForProjectImplementation = mockResolveVersionActionsForProjectImplementation;
-const j_toml_1 = require("@ltd/j-toml");
-const node_path_1 = require("node:path");
-const json_1 = require("../../../generators/utils/json");
-const file_map_utils_1 = require("../../../project-graph/file-map-utils");
-const config_1 = require("../config/config");
-const filter_release_groups_1 = require("../config/filter-release-groups");
-const version_actions_1 = require("./version-actions");
-async function createNxReleaseConfigAndPopulateWorkspace(tree, graphDefinition, additionalNxReleaseConfig, mockResolveCurrentVersion, filters = {}) {
-    const graph = parseGraphDefinition(graphDefinition);
-    const { groups, projectGraph } = setupGraph(tree, graph);
-    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), {
-        ...additionalNxReleaseConfig,
-        groups,
-        version: {
-            ...additionalNxReleaseConfig.version,
-            useLegacyVersioning: false,
-        },
-    });
-    if (configError) {
-        throw configError;
-    }
-    let { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, filters.projects, filters.groups);
-    if (filterError) {
-        throw filterError;
-    }
-    // Mock the implementation of resolveCurrentVersion to reliably return the version of the project based on our graph definition
-    mockResolveCurrentVersion?.mockImplementation((_, { name }) => {
-        for (const [projectName, project] of Object.entries(graph.projects)) {
-            if (projectName === name) {
-                return project.version ?? null;
-            }
-        }
-        throw new Error(`Unknown project name in test utils: ${name}`);
-    });
-    return {
-        projectGraph,
-        nxReleaseConfig: nxReleaseConfig,
-        releaseGroups,
-        releaseGroupToFilteredProjects,
-        filters,
-    };
-}
-class ExampleRustVersionActions extends version_actions_1.VersionActions {
-    constructor() {
-        super(...arguments);
-        this.validManifestFilenames = ['Cargo.toml'];
-    }
-    parseCargoToml(cargoString) {
-        return j_toml_1.default.parse(cargoString, {
-            x: { comment: true },
-        });
-    }
-    static stringifyCargoToml(cargoToml) {
-        const tomlString = j_toml_1.default.stringify(cargoToml, {
-            newlineAround: 'section',
-        });
-        return Array.isArray(tomlString) ? tomlString.join('\n') : tomlString;
-    }
-    static modifyCargoTable(toml, section, key, value) {
-        toml[section] ??= j_toml_1.default.Section({});
-        toml[section][key] =
-            typeof value === 'object' && !Array.isArray(value)
-                ? j_toml_1.default.inline(value)
-                : typeof value === 'function'
-                    ? value()
-                    : value;
-    }
-    async readCurrentVersionFromSourceManifest(tree) {
-        const cargoTomlPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'Cargo.toml');
-        const cargoTomlString = tree.read(cargoTomlPath, 'utf-8').toString();
-        const cargoToml = this.parseCargoToml(cargoTomlString);
-        const currentVersion = cargoToml.package?.version || '0.0.0';
-        return {
-            currentVersion,
-            manifestPath: cargoTomlPath,
-        };
-    }
-    async readCurrentVersionFromRegistry(tree, _currentVersionResolverMetadata) {
-        // Real registry resolver not needed for this test example
-        return {
-            currentVersion: (await this.readCurrentVersionFromSourceManifest(tree))
-                .currentVersion,
-            logText: 'https://example.com/fake-registry',
-        };
-    }
-    async updateProjectVersion(tree, newVersion) {
-        const logMessages = [];
-        for (const manifestPath of this.manifestsToUpdate) {
-            const cargoTomlString = tree.read(manifestPath, 'utf-8').toString();
-            const cargoToml = this.parseCargoToml(cargoTomlString);
-            ExampleRustVersionActions.modifyCargoTable(cargoToml, 'package', 'version', newVersion);
-            const updatedCargoTomlString = ExampleRustVersionActions.stringifyCargoToml(cargoToml);
-            tree.write(manifestPath, updatedCargoTomlString);
-            logMessages.push(`✍️  New version ${newVersion} written to manifest: ${manifestPath}`);
-        }
-        return logMessages;
-    }
-    async readCurrentVersionOfDependency(tree, _projectGraph, dependencyProjectName) {
-        const cargoTomlPath = (0, node_path_1.join)(this.projectGraphNode.data.root, 'Cargo.toml');
-        const cargoTomlString = tree.read(cargoTomlPath, 'utf-8').toString();
-        const cargoToml = this.parseCargoToml(cargoTomlString);
-        const dependencyVersion = cargoToml.dependencies?.[dependencyProjectName];
-        if (typeof dependencyVersion === 'string') {
-            return {
-                currentVersion: dependencyVersion,
-                dependencyCollection: 'dependencies',
-            };
-        }
-        return {
-            currentVersion: dependencyVersion?.version || '0.0.0',
-            dependencyCollection: 'dependencies',
-        };
-    }
-    async isLocalDependencyProtocol(_versionSpecifier) {
-        return false;
-    }
-    async updateProjectDependencies(tree, _projectGraph, dependenciesToUpdate) {
-        const numDependenciesToUpdate = Object.keys(dependenciesToUpdate).length;
-        const depText = numDependenciesToUpdate === 1 ? 'dependency' : 'dependencies';
-        if (numDependenciesToUpdate === 0) {
-            return [];
-        }
-        const logMessages = [];
-        for (const manifestPath of this.manifestsToUpdate) {
-            const cargoTomlString = tree.read(manifestPath, 'utf-8').toString();
-            const cargoToml = this.parseCargoToml(cargoTomlString);
-            for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
-                ExampleRustVersionActions.modifyCargoTable(cargoToml, 'dependencies', dep, version);
-            }
-            const updatedCargoTomlString = ExampleRustVersionActions.stringifyCargoToml(cargoToml);
-            tree.write(manifestPath, updatedCargoTomlString);
-            logMessages.push(`✍️  Updated ${numDependenciesToUpdate} ${depText} in manifest: ${manifestPath}`);
-        }
-        return logMessages;
-    }
-}
-exports.ExampleRustVersionActions = ExampleRustVersionActions;
-class ExampleNonSemverVersionActions extends version_actions_1.VersionActions {
-    constructor() {
-        super(...arguments);
-        this.validManifestFilenames = null;
-    }
-    async readCurrentVersionFromSourceManifest() {
-        return null;
-    }
-    async readCurrentVersionFromRegistry() {
-        return null;
-    }
-    async readCurrentVersionOfDependency() {
-        return {
-            currentVersion: null,
-            dependencyCollection: null,
-        };
-    }
-    async isLocalDependencyProtocol() {
-        return false;
-    }
-    async updateProjectVersion(tree, newVersion) {
-        tree.write((0, node_path_1.join)(this.projectGraphNode.data.root, 'version.txt'), newVersion);
-        return [];
-    }
-    async updateProjectDependencies() {
-        return [];
-    }
-    // Overwrite the default calculateNewVersion method to return the new version directly and not consider semver
-    async calculateNewVersion(currentVersion, newVersionInput, newVersionInputReason, newVersionInputReasonData, preid) {
-        if (newVersionInput === 'patch') {
-            return {
-                newVersion: '{SOME_NEW_VERSION_DERIVED_AS_A_SIDE_EFFECT_OF_DEPENDENCY_BUMP}',
-                logText: `Determined new version as a side effect of dependency bump: ${newVersionInput}`,
-            };
-        }
-        return {
-            newVersion: newVersionInput,
-            logText: `Applied new version directly: ${newVersionInput}`,
-        };
-    }
-}
-exports.ExampleNonSemverVersionActions = ExampleNonSemverVersionActions;
-function parseGraphDefinition(definition) {
-    const graph = { projects: {} };
-    const lines = definition.trim().split('\n');
-    let currentGroup = '';
-    let groupConfig = {};
-    let groupRelationship = '';
-    let lastProjectName = '';
-    lines.forEach((line) => {
-        line = line.trim();
-        if (!line) {
-            // Skip empty lines
-            return;
-        }
-        // Match group definitions with JSON config
-        const groupMatch = line.match(/^(\w+)\s*\(\s*(\{.*?\})\s*\):$/);
-        if (groupMatch) {
-            currentGroup = groupMatch[1];
-            groupConfig = JSON.parse(groupMatch[2]);
-            groupRelationship = groupConfig['projectsRelationship'] || 'independent';
-            return;
-        }
-        // Match project definitions with optional per-project JSON config
-        const projectMatch = line.match(/^- ([\w-]+)(?:\[([\w\/-]+)\])?(?:@([\w\.-]+))? \[([\w-]+)(?::([^[\]]+))?\](?:\s*\(\s*(\{.*?\})\s*\))?$/);
-        if (projectMatch) {
-            const [_, name, customProjectRoot, version, language, alternateNameInManifest, configJson,] = projectMatch;
-            // Automatically add data for Rust projects
-            let projectData = {};
-            if (customProjectRoot) {
-                projectData.root = customProjectRoot;
-            }
-            if (language === 'rust') {
-                projectData = {
-                    release: { versionActions: exampleRustVersionActions },
-                };
-            }
-            else if (language === 'non-semver') {
-                projectData = {
-                    release: { versionActions: exampleNonSemverVersionActions },
-                };
-            }
-            // Merge explicit per-project config if present
-            if (configJson) {
-                const explicitConfig = JSON.parse(configJson);
-                projectData = { ...projectData, ...explicitConfig };
-            }
-            graph.projects[name] = {
-                version: version ?? null,
-                language,
-                group: currentGroup,
-                relationship: groupRelationship,
-                dependsOn: [],
-                data: projectData,
-                // E.g. package name in package.json doesn't necessarily match the name of the nx project
-                alternateNameInManifest,
-            };
-            lastProjectName = name;
-            return;
-        }
-        // Match release config overrides
-        const releaseConfigMatch = line.match(/^-> release config overrides (\{.*\})$/);
-        if (releaseConfigMatch) {
-            const [_, releaseConfigJson] = releaseConfigMatch;
-            const releaseConfigOverrides = JSON.parse(releaseConfigJson);
-            if (!graph.projects[lastProjectName].releaseConfigOverrides) {
-                graph.projects[lastProjectName].releaseConfigOverrides = {};
-            }
-            graph.projects[lastProjectName].releaseConfigOverrides = {
-                ...graph.projects[lastProjectName].releaseConfigOverrides,
-                ...releaseConfigOverrides,
-            };
-            return;
-        }
-        // Match dependencies
-        const dependsMatch = line.match(/^-> depends on ([~^=]?)([\w-]+)(?:\((.*?)\))?(?:\s*\{(\w+)\})?$/);
-        if (dependsMatch) {
-            const [_, prefix, depProject, versionSpecifier, depCollection = 'dependencies',] = dependsMatch;
-            // Add the dependency to the last added project
-            if (!graph.projects[lastProjectName].dependsOn) {
-                graph.projects[lastProjectName].dependsOn = [];
-            }
-            graph.projects[lastProjectName].dependsOn.push({
-                project: depProject,
-                collection: depCollection,
-                prefix: prefix || '', // Store the prefix (empty string if not specified)
-                versionSpecifier: versionSpecifier || undefined, // Store exact version specifier if provided
-            });
-            return;
-        }
-        // Ignore unrecognized lines
-    });
-    return graph;
-}
-function setupGraph(tree, graph) {
-    const groups = {};
-    const projectGraph = { nodes: {}, dependencies: {} };
-    for (const [projectName, projectData] of Object.entries(graph.projects)) {
-        const { version, language, group, relationship, dependsOn, data, alternateNameInManifest, releaseConfigOverrides, } = projectData;
-        const packageName = alternateNameInManifest ?? projectName;
-        // Write project files based on language
-        if (language === 'js') {
-            const packageJson = {
-                name: packageName,
-                version,
-            };
-            if (dependsOn) {
-                dependsOn.forEach((dep) => {
-                    if (!packageJson[dep.collection]) {
-                        packageJson[dep.collection] = {};
-                    }
-                    const depNode = graph.projects[dep.project];
-                    const depVersion = dep.versionSpecifier ?? depNode.version;
-                    packageJson[dep.collection][depNode.alternateNameInManifest ?? dep.project] = `${dep.prefix}${depVersion}`;
-                });
-            }
-            (0, json_1.writeJson)(tree, (0, node_path_1.join)(data.root ?? projectName, 'package.json'), packageJson);
-            // Write extra manifest files if specified
-            if (releaseConfigOverrides?.version?.manifestRootsToUpdate) {
-                releaseConfigOverrides.version.manifestRootsToUpdate.forEach((root) => {
-                    (0, json_1.writeJson)(tree, (0, node_path_1.join)(root, 'package.json'), packageJson);
-                });
-            }
-        }
-        else if (language === 'rust') {
-            const cargoToml = {};
-            ExampleRustVersionActions.modifyCargoTable(cargoToml, 'package', 'name', projectName);
-            ExampleRustVersionActions.modifyCargoTable(cargoToml, 'package', 'version', version);
-            if (dependsOn) {
-                dependsOn.forEach((dep) => {
-                    ExampleRustVersionActions.modifyCargoTable(cargoToml, dep.collection, dep.project, {
-                        version: dep.versionSpecifier ?? graph.projects[dep.project].version,
-                    });
-                });
-            }
-            const contents = ExampleRustVersionActions.stringifyCargoToml(cargoToml);
-            tree.write((0, node_path_1.join)(data.root ?? projectName, 'Cargo.toml'), contents);
-            // Write extra manifest files if specified
-            if (releaseConfigOverrides?.version?.manifestRootsToUpdate) {
-                releaseConfigOverrides.version.manifestRootsToUpdate.forEach((root) => {
-                    tree.write((0, node_path_1.join)(root, 'Cargo.toml'), contents);
-                });
-            }
-        }
-        else if (language === 'non-semver') {
-            tree.write((0, node_path_1.join)(data.root ?? projectName, 'version.txt'), version ?? '');
-        }
-        // Add to projectGraph nodes
-        const projectGraphProjectNode = {
-            name: projectName,
-            type: 'lib',
-            data: {
-                root: projectName,
-                ...data, // Merge any additional data from project config
-            },
-        };
-        if (language === 'js') {
-            // Always add the js package metadata to match the @nx/js plugin
-            projectGraphProjectNode.data.metadata = {
-                js: {
-                    packageName,
-                },
-            };
-        }
-        // Add project level release config overrides
-        if (releaseConfigOverrides) {
-            projectGraphProjectNode.data.release = {
-                ...projectGraphProjectNode.data.release,
-                ...releaseConfigOverrides,
-            };
-        }
-        projectGraph.nodes[projectName] = projectGraphProjectNode;
-        // Initialize dependencies
-        projectGraph.dependencies[projectName] = [];
-        // Handle dependencies
-        if (dependsOn) {
-            dependsOn.forEach((dep) => {
-                projectGraph.dependencies[projectName].push({
-                    source: projectName,
-                    target: dep.project,
-                    type: 'static',
-                });
-            });
-        }
-        // Add to releaseGroups
-        if (!groups[group]) {
-            groups[group] = {
-                projectsRelationship: relationship,
-                projects: [],
-            };
-        }
-        groups[group].projects.push(projectName);
-    }
-    return { groups, projectGraph };
-}
-const exampleRustVersionActions = '__EXAMPLE_RUST_VERSION_ACTIONS__';
-const exampleNonSemverVersionActions = '__EXAMPLE_NON_SEMVER_VERSION_ACTIONS__';
-async function mockResolveVersionActionsForProjectImplementation(tree, releaseGroup, projectGraphNode, finalConfigForProject) {
-    if (projectGraphNode.data.release?.versionActions ===
-        exampleRustVersionActions ||
-        releaseGroup.versionActions === exampleRustVersionActions) {
-        const versionActions = new ExampleRustVersionActions(releaseGroup, projectGraphNode, finalConfigForProject);
-        // Initialize the versionActions with all the required manifest paths etc
-        await versionActions.init(tree);
-        return {
-            versionActionsPath: exampleRustVersionActions,
-            versionActions,
-        };
-    }
-    if (projectGraphNode.data.release?.versionActions ===
-        exampleNonSemverVersionActions ||
-        releaseGroup.versionActions === exampleNonSemverVersionActions) {
-        const versionActions = new ExampleNonSemverVersionActions(releaseGroup, projectGraphNode, finalConfigForProject);
-        // Initialize the versionActions with all the required manifest paths etc
-        await versionActions.init(tree);
-        return {
-            versionActionsPath: exampleNonSemverVersionActions,
-            versionActions,
-        };
-    }
-    const versionActionsPath = config_1.DEFAULT_VERSION_ACTIONS_PATH;
-    // @ts-ignore
-    const loaded = jest.requireActual(versionActionsPath);
-    const JsVersionActions = loaded.default;
-    const versionActions = new JsVersionActions(releaseGroup, projectGraphNode, finalConfigForProject);
-    // Initialize the versionActions with all the required manifest paths etc
-    await versionActions.init(tree);
-    return {
-        versionActionsPath,
-        versionActions: versionActions,
-        afterAllProjectsVersioned: loaded.afterAllProjectsVersioned,
-    };
-}

package/src/command-line/release/version/topological-sort.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.topologicalSort = topologicalSort;
-/**
- * Topologically sorts a directed graph, returning the sorted nodes.
- * Handles cycles by breaking them where needed.
- *
- * @param nodes All nodes in the graph
- * @param getEdges Function that returns outgoing edges for a node
- * @returns Topologically sorted list of nodes
- */
-function topologicalSort(nodes, getEdges) {
-    const result = [];
-    const visited = new Set();
-    const temp = new Set();
-    function visit(node) {
-        // Node is already in result
-        if (visited.has(node)) {
-            return;
-        }
-        // Cycle detected, skip this edge to break the cycle
-        if (temp.has(node)) {
-            return;
-        }
-        temp.add(node);
-        // Visit all dependencies first
-        for (const dep of getEdges(node)) {
-            visit(dep);
-        }
-        temp.delete(node);
-        visited.add(node);
-        result.push(node);
-    }
-    // Visit all nodes
-    for (const node of nodes) {
-        if (!visited.has(node)) {
-            visit(node);
-        }
-    }
-    return result.reverse();
-}

package/src/command-line/release/version/version-actions.d.ts

@@ -1,170 +0,0 @@
-import { ReleaseType } from 'semver';
-import { NxReleaseVersionV2Configuration } from '../../../config/nx-json';
-import type { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode } from '../../../config/project-graph';
-import type { Tree } from '../../../generators/tree';
-import { ReleaseGroupWithName } from '../config/filter-release-groups';
-import { FinalConfigForProject } from './release-group-processor';
-export type SemverBumpType = ReleaseType | 'none';
-/**
- * Implementation details of performing any actions after all projects have been versioned.
- * An example might be updating a workspace level lock file.
- *
- * NOTE: By the time this function is invoked, the tree will have been flushed back to disk,
- * so it is not accessible here.
- *
- * The function should return lists of changed and deleted files so that they can be staged
- * and committed if appropriate.
- *
- * NOTE: The versionActionsOptions passed here are the ones at the root of release.version config,
- * different values per release group or project will not be respected here because this takes
- * place after all projects have been versioned.
- */
-export type AfterAllProjectsVersioned = (cwd: string, opts: {
-    dryRun?: boolean;
-    verbose?: boolean;
-    rootVersionActionsOptions?: Record<string, unknown>;
-}) => Promise<{
-    changedFiles: string[];
-    deletedFiles: string[];
-}>;
-export declare function resolveVersionActionsForProject(tree: Tree, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject): Promise<{
-    versionActionsPath: string;
-    versionActions: VersionActions;
-    afterAllProjectsVersioned: AfterAllProjectsVersioned;
-}>;
-export declare abstract class VersionActions {
-    releaseGroup: ReleaseGroupWithName;
-    projectGraphNode: ProjectGraphProjectNode;
-    finalConfigForProject: FinalConfigForProject;
-    /**
-     * The available valid filenames of the manifest file relevant to the current versioning use-case.
-     *
-     * E.g. for JavaScript projects this would be ["package.json"], but for Gradle it would be
-     * ["build.gradle", "build.gradle.kts"].
-     *
-     * If a manifest file is not applicable to the current versioning use-case, this should be set to null.
-     */
-    abstract validManifestFilenames: string[] | null;
-    /**
-     * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
-     * versions and dependencies are determined. If no manifest files should be updated based on the user's
-     * configuration, this will be an empty array.
-     */
-    manifestsToUpdate: string[];
-    constructor(releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, finalConfigForProject: FinalConfigForProject);
-    /**
-     * Asynchronous initialization of the version actions and validation of certain configuration options.
-     */
-    init(tree: Tree): Promise<void>;
-    /**
-     * The default implementation will calculate the new version based on semver. If semver is not applicable to a
-     * particular versioning use-case, this method should be overridden with custom logic.
-     *
-     * @param {string | null} currentVersion - The current version of the project, or null if the current version resolver is set to 'none'
-     * @param {string} newVersionInput - The new version input provided by the user, such as a semver relative bump type, or an explicit version
-     * @param {string} newVersionInputReason - The reason for the new version input used to inform the log message to show to the user
-     * @param {Record<string, unknown>} newVersionInputReasonData - The data to interpolate into the new version input reason
-     * @param {string} preid - The preid to use for the new version, if applicable
-     */
-    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
-        newVersion: string;
-        logText: string;
-    }>;
-    /**
-     * Implementation details of resolving a project's current version from a valid manifest file. It should
-     * return an object with the current version and the filename of the resolved manifest path so that the
-     * logs provided to the user are as specific as possible.
-     *
-     * This method will only be called if the user has configured their currentVersionResolver to be "disk".
-     *
-     * If the version actions implementation does not support a manifest file, this method can either throw
-     * an error or return null. In this case, nx release will handle showing the user a relevant error about
-     * their currentVersionResolver configuration being fundamentally incompatible with the current version
-     * actions implementation resolved for the project being versioned and they can change it to something else
-     * (e.g. "registry" or "git-tag").
-     *
-     * NOTE: The version actions implementation does not need to provide the method for handling resolution
-     * from git tags, this is done directly by nx release.
-     */
-    abstract readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
-        currentVersion: string;
-        manifestPath: string;
-    } | null>;
-    /**
-     * Implementation details of resolving a project's current version from a remote registry.
-     *
-     * The specific logText it returns will be combined with the generic remote registry log text and allows
-     * the implementation to provide more specific information to the user about what registry URL
-     * was used, what dist-tag etc.
-     *
-     * If the version actions implementation does not support resolving from a remote registry, this method
-     * can either throw an error or return null. In this case, nx release will handle showing the user a relevant
-     * error about their currentVersionResolver configuration being fundamentally incompatible with the current
-     * version actions implementation resolved for the project being versioned and they can change it to something
-     * else (e.g. "disk" or "git-tag").
-     *
-     * NOTE: The version actions implementation does not need to provide the method for handling resolution
-     * from git tags, this is done directly by nx release.
-     */
-    abstract readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata']): Promise<{
-        currentVersion: string | null;
-        logText: string;
-    } | null>;
-    /**
-     * Implementation details of resolving the dependencies of a project.
-     *
-     * The default implementation will read dependencies from the Nx project graph. In many cases this will be sufficient,
-     * because the project graph will have been constructed using plugins from relevant ecosystems that should have applied
-     * any and all relevant metadata to the project nodes and dependency edges.
-     *
-     * If, however, the project graph cannot be used as the source of truth for whatever reason, then this default method
-     * can simply be overridden in the final version actions implementation.
-     */
-    readDependencies(tree: Tree, projectGraph: ProjectGraph): Promise<ProjectGraphDependency[]>;
-    /**
-     * Implementation details of resolving the current version of a specific dependency of the project.
-     *
-     * The dependency collection is the type of dependency collection to which the dependency belongs, such as 'dependencies',
-     * 'devDependencies', 'peerDependencies', 'optionalDependencies', etc. This is ecosystem and use-case specific.
-     *
-     * The currentVersion and dependencyCollection fields will be used to populate the rawVersionSpec and dependencyCollection
-     * fields on the VersionData that gets returned from the programmatic API. `null` values are accepted for these if the current
-     * version or dependencyCollection is not applicable/resolvable at all, but they should be provided if possible.
-     *
-     * The currentVersion will also be used when calculating the final versionPrefix to apply for the new dependency
-     * version, based on the user's configuration, if applicable.
-     */
-    abstract readCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
-        currentVersion: string | null;
-        dependencyCollection: string | null;
-    }>;
-    /**
-     * Implementation details of determining if a version specifier uses a local dependency protocol that is relevant to this
-     * specific project. E.g. in a package.json context, `file:` and `workspace:` protocols should return true here.
-     */
-    abstract isLocalDependencyProtocol(versionSpecifier: string): Promise<boolean>;
-    /**
-     * Implementation details of updating a newly derived version in some source of truth.
-     *
-     * For libraries/packages, this will usually involve writing to one or more manifest files
-     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc, but for
-     * application deployments it might involve updating something else instead, it depends on
-     * the type of application.
-     *
-     * It should return an array of log messages that will be displayed unmodified to the user
-     * after the version has been updated.
-     */
-    abstract updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
-    /**
-     * Implementation details of updating dependencies in some source of truth.
-     *
-     * For libraries/packages, this will usually involve writing to one or more manifest files
-     * (e.g. potentially both src and dist), such as a package.json/Cargo.toml/etc,
-     * with new dependency versions, but for application deployments it might involve
-     * updating something else instead, it depends on the type of application.
-     *
-     * It should return an array of log messages that will be displayed unmodified to the user
-     * after the dependencies have been updated.
-     */
-    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
-}