@depup/nx 22.5.4-depup.0

package/src/command-line/release/version/resolve-current-version.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCurrentVersion = resolveCurrentVersion;
+exports.resolveCurrentVersionFromDisk = resolveCurrentVersionFromDisk;
+exports.resolveCurrentVersionFromRegistry = resolveCurrentVersionFromRegistry;
+exports.resolveCurrentVersionFromGitTag = resolveCurrentVersionFromGitTag;
+const pc = require("picocolors");
+const enquirer_1 = require("enquirer");
+const spinner_1 = require("../../../utils/spinner");
+async function resolveCurrentVersion(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag) {
+    switch (finalConfigForProject.currentVersionResolver) {
+        case 'none':
+            return null;
+        case 'disk': {
+            return resolveCurrentVersionFromDisk(tree, projectGraphNode, versionActions, logger);
+        }
+        case 'registry': {
+            return resolveCurrentVersionFromRegistry(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject);
+        }
+        case 'git-tag': {
+            return resolveCurrentVersionFromGitTag(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag);
+        }
+        default:
+            throw new Error(`Invalid value for "currentVersionResolver": ${finalConfigForProject.currentVersionResolver}`);
+    }
+}
+/**
+ * Attempt to resolve the current version from the manifest file on disk.
+ *
+ * Not all VersionActions implementations support a manifest file, in which case the logic will handle either thrown errors
+ * or null values being returned from the readCurrentVersionFromSourceManifest method and throw a clear user-facing error.
+ */
+async function resolveCurrentVersionFromDisk(tree, projectGraphNode, versionActions, logger) {
+    if (!versionActions.validManifestFilenames?.length) {
+        throw new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "disk" but it is using "versionActions" of type "${versionActions.constructor.name}". This is invalid because "${versionActions.constructor.name}" does not support a manifest file. You should use a different "currentVersionResolver" or use a different "versionActions" implementation that supports a manifest file`);
+    }
+    const nullVersionError = new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "disk" and it is using "versionActions" of type "${versionActions.constructor.name}" which failed to resolve the current version from the manifest file on disk`);
+    try {
+        const res = await versionActions.readCurrentVersionFromSourceManifest(tree);
+        if (!res) {
+            throw nullVersionError;
+        }
+        const { currentVersion, manifestPath } = res;
+        logger.buffer(`📄 Resolved the current version as ${currentVersion} from manifest: ${manifestPath}`);
+        return currentVersion;
+    }
+    catch (err) {
+        if (err === nullVersionError) {
+            throw err;
+        }
+        throw new Error(`The project "${projectGraphNode.name}" does not have a ${versionActions.validManifestFilenames.join(' or ')} file available in ${projectGraphNode.data.root}
+
+To fix this you will either need to add a ${versionActions.validManifestFilenames.join(' or ')} file at that location, or configure "release" within your nx.json to use a different "currentVersionResolver" or "versionActions" implementation that supports this setup`);
+    }
+}
+async function resolveCurrentVersionFromRegistry(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject) {
+    /**
+     * In the case of fixed release groups that are configured to resolve the current version from a registry,
+     * it would be a waste of time and resources to make requests to the registry, or resolve one of the fallbacks,
+     * for each individual project, therefore we maintain a cache of the current version for each applicable release group here.
+     */
+    const cached = cachedCurrentVersionsPerFixedReleaseGroup.get(releaseGroup.name);
+    if (cached) {
+        const logText = cached.logText ? ` ${cached.logText}` : '';
+        logger.buffer(`🔄 Reusing the current version ${cached.currentVersion} already resolved for ${cached.originatingProjectName}${logText}`);
+        return cached.currentVersion;
+    }
+    let registryTxt = '';
+    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`);
+    try {
+        const res = await versionActions.readCurrentVersionFromRegistry(tree, finalConfigForProject.currentVersionResolverMetadata);
+        if (!res) {
+            // Not a user-facing error
+            throw new Error('Registry not applicable for this version actions implementation');
+        }
+        const { currentVersion, logText } = res;
+        spinner.stop();
+        registryTxt = logText?.length > 0 ? `: ${logText}` : '';
+        if (!currentVersion) {
+            // Not a user-facing error
+            throw new Error('No version found in the registry');
+        }
+        logger.buffer(`🔍 Resolved the current version as ${currentVersion} from the remote registry${registryTxt}`);
+        // Write to the cache if the release group is fixed
+        if (releaseGroup.projectsRelationship === 'fixed') {
+            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+                currentVersion,
+                originatingProjectName: projectGraphNode.name,
+                logText: `from the registry${registryTxt}`,
+            });
+        }
+        return currentVersion;
+    }
+    catch {
+        spinner.stop();
+        if (finalConfigForProject.fallbackCurrentVersionResolver === 'disk') {
+            if (!versionActions.validManifestFilenames?.length) {
+                throw new Error(`For project "${projectGraphNode.name}", the "currentVersionResolver" is set to "registry" with a "fallbackCurrentVersionResolver" of "disk" but it is using "versionActions" of type "${versionActions.constructor.name}". This is invalid because "${versionActions.constructor.name}" does not support a manifest file. You should use a different "fallbackCurrentVersionResolver" or use a different "versionActions" implementation that supports a manifest file`);
+            }
+            const fromDiskRes = await versionActions.readCurrentVersionFromSourceManifest(tree);
+            // Fallback on disk is available, return it directly
+            if (fromDiskRes && fromDiskRes.currentVersion) {
+                logger.buffer(`⚠️  Unable to resolve the current version from the registry${registryTxt}. Falling back to the version ${fromDiskRes.currentVersion} in manifest: ${fromDiskRes.manifestPath}`);
+                // Write to the cache if the release group is fixed
+                if (releaseGroup.projectsRelationship === 'fixed') {
+                    cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+                        currentVersion: fromDiskRes.currentVersion,
+                        originatingProjectName: projectGraphNode.name,
+                        logText: `from the disk fallback`,
+                    });
+                }
+                return fromDiskRes.currentVersion;
+            }
+        }
+        // At this point the fallback on disk is also not available/configured, allow one final interactive fallback, but only when using version-plans or conventional-commits
+        if (finalConfigForProject.specifierSource === 'prompt') {
+            throw new Error(`Unable to resolve the current version from the registry${registryTxt}. Please ensure that the package exists in the registry in order to use the "registry" currentVersionResolver. Alternatively, you can use the --first-release option or set "release.version.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when the registry lookup fails.`);
+        }
+        const currentVersionFromPromptFallback = await handleNoAvailableDiskFallback({
+            logger,
+            projectName: projectGraphNode.name,
+            versionActions,
+            specifierSource: finalConfigForProject.specifierSource,
+            currentVersionSourceMessage: `from the registry${registryTxt}`,
+            resolutionSuggestion: `you should publish an initial version to the registry`,
+        });
+        // Write to the cache if the release group is fixed
+        if (releaseGroup.projectsRelationship === 'fixed') {
+            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+                currentVersion: currentVersionFromPromptFallback,
+                originatingProjectName: projectGraphNode.name,
+                logText: `from the prompt fallback`,
+            });
+        }
+        return currentVersionFromPromptFallback;
+    }
+}
+async function resolveCurrentVersionFromGitTag(tree, projectGraphNode, releaseGroup, versionActions, logger, cachedCurrentVersionsPerFixedReleaseGroup, finalConfigForProject, releaseTagPattern, latestMatchingGitTag) {
+    /**
+     * In the case of fixed release groups that are configured to resolve the current version from a git tag,
+     * it would be a waste of time and resources to figure out the git tag, or resolve one of the fallbacks,
+     * for each individual project, therefore we maintain a cache of the current version for each applicable release group here.
+     */
+    const cached = cachedCurrentVersionsPerFixedReleaseGroup.get(releaseGroup.name);
+    if (cached) {
+        const logText = cached.logText ? ` ${cached.logText}` : '';
+        logger.buffer(`🔄 Reusing the current version ${cached.currentVersion} already resolved for ${cached.originatingProjectName}${logText}`);
+        return cached.currentVersion;
+    }
+    // The latest matching git tag was found in release-group-processor and has an extracted version, return it directly
+    if (latestMatchingGitTag && latestMatchingGitTag.extractedVersion) {
+        const currentVersion = latestMatchingGitTag.extractedVersion;
+        logger.buffer(`🏷️  Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}", based on releaseTagPattern "${releaseTagPattern}"`);
+        // Write to the cache if the release group is fixed
+        if (releaseGroup.projectsRelationship === 'fixed') {
+            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+                currentVersion,
+                originatingProjectName: projectGraphNode.name,
+                logText: `from git tag "${latestMatchingGitTag.tag}"`,
+            });
+        }
+        return currentVersion;
+    }
+    const noMatchingGitTagsError = new Error(`No git tags matching pattern "${releaseTagPattern}" for project "${projectGraphNode.name}" were found. You will need to create an initial matching tag to use as a base for determining the next version. Alternatively, you can use the --first-release option or set "release.version.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when no matching git tags are found.`);
+    if (finalConfigForProject.fallbackCurrentVersionResolver !== 'disk') {
+        throw noMatchingGitTagsError;
+    }
+    const fromDiskRes = await versionActions.readCurrentVersionFromSourceManifest(tree);
+    // Fallback on disk is available, return it directly
+    if (fromDiskRes && fromDiskRes.currentVersion) {
+        logger.buffer(`⚠️  Unable to resolve the current version from git tags using pattern "${releaseTagPattern}". Falling back to the version ${fromDiskRes.currentVersion} in manifest: ${fromDiskRes.manifestPath}`);
+        // Write to the cache if the release group is fixed
+        if (releaseGroup.projectsRelationship === 'fixed') {
+            cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+                currentVersion: fromDiskRes.currentVersion,
+                originatingProjectName: projectGraphNode.name,
+                logText: `from the disk fallback`,
+            });
+        }
+        return fromDiskRes.currentVersion;
+    }
+    // At this point the fallback on disk is also not available/configured, allow one final interactive fallback, but only when using version-plans or conventional-commits
+    if (finalConfigForProject.specifierSource === 'prompt') {
+        throw noMatchingGitTagsError;
+    }
+    const currentVersionFromPromptFallback = await handleNoAvailableDiskFallback({
+        logger,
+        projectName: projectGraphNode.name,
+        versionActions,
+        specifierSource: finalConfigForProject.specifierSource,
+        currentVersionSourceMessage: `from git tag using pattern "${releaseTagPattern}"`,
+        resolutionSuggestion: `you should set an initial git tag on a relevant commit`,
+    });
+    // Write to the cache if the release group is fixed
+    if (releaseGroup.projectsRelationship === 'fixed') {
+        cachedCurrentVersionsPerFixedReleaseGroup.set(releaseGroup.name, {
+            currentVersion: currentVersionFromPromptFallback,
+            originatingProjectName: projectGraphNode.name,
+            logText: `from the prompt fallback`,
+        });
+    }
+    return currentVersionFromPromptFallback;
+}
+/**
+ * Allow users to be unblocked when locally running releases for the very first time with certain combinations that require an initial
+ * version in order to function (e.g. a relative semver bump derived via conventional-commits or version-plans) by providing an interactive
+ * prompt to let them opt into using 0.0.0 as the implied current version.
+ */
+async function handleNoAvailableDiskFallback({ logger, projectName, versionActions, specifierSource, currentVersionSourceMessage, resolutionSuggestion, }) {
+    if (!versionActions.validManifestFilenames?.length) {
+        throw new Error(`Unable to resolve the current version ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version. To resolve this, ${resolutionSuggestion}, or set use a versionActions implementation that supports a manifest file`);
+    }
+    const validManifestFilenames = versionActions.validManifestFilenames.join(' or ');
+    const unresolvableCurrentVersionError = new Error(`Unable to resolve the current version ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version. To resolve this, ${resolutionSuggestion}, or set an appropriate version in a supported manifest file such as ${validManifestFilenames}`);
+    if (process.env.CI === 'true') {
+        // We can't prompt in CI, so error immediately
+        throw unresolvableCurrentVersionError;
+    }
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'useZero',
+                message: `\n${pc.yellow(`Warning: Unable to resolve the current version for "${projectName}" ${currentVersionSourceMessage} and there is no version on disk to fall back to. This is invalid with ${specifierSource} because the new version is determined by relatively bumping the current version.\n\nTo resolve this, ${resolutionSuggestion}, or set an appropriate version in a supported manifest file such as ${validManifestFilenames}`)}. \n\nAlternatively, would you like to continue now by using 0.0.0 as the current version?`,
+                type: 'confirm',
+                initial: false,
+            },
+        ]);
+        if (!reply.useZero) {
+            // Throw any error to skip the fallback to 0.0.0, may as well use the one we already have
+            throw unresolvableCurrentVersionError;
+        }
+        const currentVersion = '0.0.0';
+        logger.buffer(`⚠  Forcibly resolved the current version as "${currentVersion}" based on your response to the prompt above`);
+        return currentVersion;
+    }
+    catch {
+        throw unresolvableCurrentVersionError;
+    }
+}

package/src/command-line/release/version/test-utils.d.ts

@@ -0,0 +1,103 @@
+import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from '../../../config/nx-json';
+import type { ProjectGraph } from '../../../config/project-graph';
+import type { Tree } from '../../../generators/tree';
+import { NxReleaseConfig } from '../config/config';
+import { type FinalConfigForProject } from '../utils/release-graph';
+import { ReleaseGroupProcessor } from './release-group-processor';
+import { VersionActions } from './version-actions';
+export declare function createNxReleaseConfigAndPopulateWorkspace(tree: Tree, graphDefinition: string, additionalNxReleaseConfig: Exclude<NxJsonConfiguration['release'], 'groups'>, mockResolveCurrentVersion?: any, filters?: {
+    projects?: string[];
+    groups?: string[];
+}): Promise<{
+    projectGraph: ProjectGraph;
+    nxReleaseConfig: NxReleaseConfig;
+    filters: {
+        projects?: string[];
+        groups?: string[];
+    };
+}>;
+export declare function createTestReleaseGroupProcessor(tree: Tree, projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, filters: {
+    projects?: string[];
+    groups?: string[];
+}, options?: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    firstRelease?: boolean;
+    preid?: string;
+    userGivenSpecifier?: string;
+}): Promise<ReleaseGroupProcessor>;
+/**
+ * A non-production grade rust implementation to prove out loading multiple different versionActions in various setups
+ */
+interface CargoToml {
+    workspace?: {
+        members: string[];
+    };
+    package: {
+        name: string;
+        version: string;
+    };
+    dependencies?: Record<string, string | {
+        version: string;
+        features?: string[];
+        optional?: boolean;
+    }>;
+    'dev-dependencies'?: Record<string, string | {
+        version: string;
+        features: string[];
+    }>;
+    [key: string]: any;
+}
+export declare class ExampleRustVersionActions extends VersionActions {
+    validManifestFilenames: string[];
+    private parseCargoToml;
+    static stringifyCargoToml(cargoToml: CargoToml): string;
+    static modifyCargoTable(toml: CargoToml, section: string, key: string, value: string | object | Array<any> | (() => any)): void;
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<{
+        currentVersion: string;
+        manifestPath: string;
+    }>;
+    readCurrentVersionFromRegistry(tree: Tree, _currentVersionResolverMetadata: NxReleaseVersionConfiguration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string;
+        logText: string;
+    }>;
+    updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
+    readCurrentVersionOfDependency(tree: Tree, _projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string;
+        dependencyCollection: string;
+    }>;
+    updateProjectDependencies(tree: Tree, _projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+}
+export declare class ExampleNonSemverVersionActions extends VersionActions {
+    validManifestFilenames: any;
+    readCurrentVersionFromSourceManifest(): Promise<any>;
+    readCurrentVersionFromRegistry(): Promise<any>;
+    readCurrentVersionOfDependency(): Promise<{
+        currentVersion: any;
+        dependencyCollection: any;
+    }>;
+    updateProjectVersion(tree: any, newVersion: any): Promise<any[]>;
+    updateProjectDependencies(): Promise<any[]>;
+    calculateNewVersion(currentVersion: string | null, newVersionInput: string, newVersionInputReason: string, newVersionInputReasonData: Record<string, unknown>, preid: string): Promise<{
+        newVersion: string;
+        logText: string;
+    }>;
+}
+export declare function parseGraphDefinition(definition: string): {
+    projects: any;
+};
+export declare function mockResolveVersionActionsForProjectImplementation(tree: Tree, releaseGroup: any, projectGraphNode: any, finalConfigForProject: FinalConfigForProject): Promise<{
+    versionActionsPath: string;
+    versionActions: ExampleRustVersionActions;
+    afterAllProjectsVersioned?: undefined;
+} | {
+    versionActionsPath: string;
+    versionActions: ExampleNonSemverVersionActions;
+    afterAllProjectsVersioned?: undefined;
+} | {
+    versionActionsPath: string;
+    versionActions: VersionActions;
+    afterAllProjectsVersioned: any;
+}>;
+export {};
+//# sourceMappingURL=test-utils.d.ts.map

package/src/command-line/release/version/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/release/version/test-utils.ts"],"names":[],"mappings":"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"}